semantifold 0.1.1 → 0.3.0

package/src/backends/go.js

@@ -0,0 +1,383 @@
+// @ts-check
+
+import {unsupportedCapability} from "../diagnostic.js"
+import {finalizeMapping, toSourceMapV3} from "../mapping.js"
+import {validateBackendModule, emitExpression} from "./shared.js"
+import {emitScalarType} from "./scalars.js"
+import {SourceWriter} from "./writer.js"
+
+const manifest = "module example.com/semantifold/generated\n\ngo 1.26.0\n"
+const binarySyntax = Object.freeze({
+  BooleanAnd: "&&", BooleanEqual: "==", BooleanNotEqual: "!=", BooleanOr: "||",
+  IntegerAdd: "+", IntegerEqual: "==", IntegerGreaterThan: ">", IntegerGreaterThanOrEqual: ">=",
+  IntegerLessThan: "<", IntegerLessThanOrEqual: "<=", IntegerMultiply: "*", IntegerNotEqual: "!=",
+  IntegerSubtract: "-", StringConcat: "+", StringEqual: "==", StringNotEqual: "!="
+})
+
+/**
+ * Emits one deterministic manifest-first Go module candidate.
+ * @param {{filename?: string, mapDirective?: unknown, module: import("../semantic/types.js").SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input Backend request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Candidate artifact set.
+ */
+export function generateGoModule({filename, mapDirective, module, sourceMapFilename, sources}) {
+  validateBackendModule(module, "go")
+  if (filename !== undefined && filename != "main.go") {
+    unsupportedCapability("go", "artifact filename other than main.go", module.location)
+  }
+  if (mapDirective !== undefined || sourceMapFilename !== undefined) {
+    unsupportedCapability("go", "source-map filename or directive option", module.location)
+  }
+  validateRoundTripMutability(module)
+  validateLocalReads(module)
+  const writer = new SourceWriter({filename: "main.go", language: "go", module, sources})
+
+  emitProgram(module, writer)
+  const mapping = finalizeMapping(writer.finish())
+  const root = mapping.nodes.find(({path}) => path == "")
+
+  if (!root) throw new Error("Validated Go module omitted its canonical root provenance.")
+  return {
+    artifacts: [{
+      content: manifest,
+      contentKind: "text",
+      mediaType: "text/plain",
+      ownership: "generated",
+      path: "go.mod",
+      provenance: {
+        kind: "synthetic",
+        reason: "Fixed example.com/semantifold/generated module identity and Go 1.26.0 configuration.",
+        relatedOrigins: relatedRootOrigins(root)
+      },
+      role: "manifest"
+    }, {
+      content: mapping.generated.content,
+      contentKind: "text",
+      mediaType: "text/x-go",
+      ownership: "generated",
+      path: "main.go",
+      provenance: {kind: "text", mapping, sourceMap: toSourceMapV3(mapping)},
+      role: "entry"
+    }],
+    target: "go"
+  }
+}
+
+/**
+ * Validates assignment-derived mutability before writer construction.
+ * @param {import("../semantic/types.js").SemanticModule} module Semantic module.
+ * @returns {void}
+ */
+function validateRoundTripMutability(module) {
+  for (const root of [...module.functions.map(({body}) => body), module.entryPoint.body]) {
+    const assigned = new Set()
+
+    visitStatements(root, (statement) => {
+      if (statement.kind == "AssignmentStatement") assigned.add(statement.target.name)
+    })
+    visitStatements(root, (statement) => {
+      if (statement.kind == "LocalDeclaration" && statement.mutable && !assigned.has(statement.name)) {
+        unsupportedCapability("go", "mutable local without a later syntactic assignment", statement.location)
+      }
+    })
+  }
+}
+
+/**
+ * Rejects locals that Go would reject as declared but never read.
+ * @param {import("../semantic/types.js").SemanticModule} module Semantic module.
+ * @returns {void}
+ */
+function validateLocalReads(module) {
+  for (const root of [...module.functions.map(({body}) => body), module.entryPoint.body]) {
+    /** @type {import("../semantic/types.js").LocalDeclaration[]} */
+    const declarations = []
+    const reads = new Set()
+
+    visitStatements(root, (statement) => {
+      if (statement.kind == "LocalDeclaration") {
+        declarations.push(statement)
+        collectIdentifierReads(statement.initializer, reads)
+      } else if (statement.kind == "IfStatement") collectIdentifierReads(statement.condition, reads)
+      else collectIdentifierReads(statement.expression, reads)
+    })
+    for (const declaration of declarations) {
+      if (!reads.has(declaration.name)) {
+        unsupportedCapability("go", `local '${declaration.name}' is never read`, declaration.location)
+      }
+    }
+  }
+}
+
+/**
+ * Collects genuine identifier reads recursively from one validated expression.
+ * @param {import("../semantic/types.js").Expression} expression Semantic expression.
+ * @param {Set<string>} reads Collected names.
+ * @returns {void}
+ */
+function collectIdentifierReads(expression, reads) {
+  if (expression.kind == "IdentifierExpression") reads.add(expression.name)
+  else if (expression.kind == "CallExpression") {
+    for (const argument of expression.arguments) collectIdentifierReads(argument, reads)
+  } else if (expression.kind == "UnaryExpression") collectIdentifierReads(expression.operand, reads)
+  else if (expression.kind == "BinaryExpression") {
+    collectIdentifierReads(expression.left, reads)
+    collectIdentifierReads(expression.right, reads)
+  }
+}
+
+/**
+ * Visits nested statements in semantic order.
+ * @param {import("../semantic/types.js").Block} block Semantic block.
+ * @param {(statement: import("../semantic/types.js").Statement) => void} callback Visitor.
+ * @returns {void}
+ */
+function visitStatements(block, callback) {
+  for (const statement of block.statements) {
+    callback(statement)
+    if (statement.kind == "IfStatement") {
+      visitStatements(statement.consequent, callback)
+      if (statement.alternate) visitStatements(statement.alternate, callback)
+    }
+  }
+}
+
+/**
+ * Reports whether any print statement requires fmt.
+ * @param {import("../semantic/types.js").SemanticModule} module Semantic module.
+ * @returns {boolean} Print presence.
+ */
+function hasPrint(module) {
+  let found = false
+
+  for (const root of [...module.functions.map(({body}) => body), module.entryPoint.body]) {
+    visitStatements(root, (statement) => {
+      if (statement.kind == "PrintStatement") found = true
+    })
+  }
+  return found
+}
+
+/**
+ * Emits the fixed Go file scaffold and semantic bodies.
+ * @param {import("../semantic/types.js").SemanticModule} module Semantic module.
+ * @param {SourceWriter} writer Source-aware writer.
+ * @returns {void}
+ */
+function emitProgram(module, writer) {
+  writer.synthetic("package main\n", "Go package scaffold", [module])
+  if (hasPrint(module)) writer.synthetic('\nimport "fmt"\n', "Go fmt print scaffold", [module])
+  module.functions.forEach((declaration, index) => {
+    writer.synthetic("\n", "declaration separator", [declaration])
+    emitFunction(writer, declaration, index)
+  })
+  writer.synthetic("\n", "entry-point separator", [module.entryPoint])
+  writer.mapped("func main", {mappingKind: "anchor", node: module.entryPoint, path: "/entryPoint"})
+  writer.mapped("()", {mappingKind: "anchor", node: module.entryPoint, path: "/entryPoint"})
+  writer.synthetic(" ", "entry-point spacing", [module.entryPoint], ["/entryPoint"])
+  writer.mapped("{", {mappingKind: "anchor", node: module.entryPoint.body, path: "/entryPoint/body"})
+  writer.synthetic("\n", "line break", [module.entryPoint], ["/entryPoint"])
+  emitBlock(writer, module.entryPoint.body, "\t", "/entryPoint/body")
+  writer.mapped("}", {mappingKind: "anchor", node: module.entryPoint, path: "/entryPoint"})
+  writer.synthetic("\n", "line break", [module.entryPoint], ["/entryPoint"])
+}
+
+/**
+ * Emits one semantic function.
+ * @param {SourceWriter} writer Source-aware writer.
+ * @param {import("../semantic/types.js").FunctionDeclaration} declaration Function declaration.
+ * @param {number} index Function index.
+ * @returns {void}
+ */
+function emitFunction(writer, declaration, index) {
+  const path = "/functions/" + index
+
+  writer.mapped("func", {mappingKind: "anchor", node: declaration, path})
+  writer.synthetic(" ", "function spacing", [declaration], [path])
+  writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, path, role: "name"})
+  writer.mapped("(", {mappingKind: "anchor", node: declaration, path})
+  declaration.parameters.forEach((parameter, parameterIndex) => {
+    const parameterPath = path + "/parameters/" + parameterIndex
+
+    if (parameterIndex > 0) writer.synthetic(", ", "parameter separator", [declaration], [path])
+    writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: parameterPath, role: "name"})
+    writer.synthetic(" ", "parameter spacing", [parameter], [parameterPath])
+    writer.mapped(emitScalarType("go", parameter.type), {
+      mappingKind: "exact", node: parameter.type, path: parameterPath + "/type", role: "type"
+    })
+  })
+  writer.mapped(")", {mappingKind: "anchor", node: declaration, path})
+  writer.synthetic(" ", "result spacing", [declaration], [path])
+  writer.mapped(emitScalarType("go", declaration.returnType), {
+    mappingKind: "exact", node: declaration.returnType, path: path + "/returnType", role: "type"
+  })
+  writer.synthetic(" ", "body spacing", [declaration], [path])
+  writer.mapped("{", {mappingKind: "anchor", node: declaration.body, path: path + "/body"})
+  writer.synthetic("\n", "line break", [declaration], [path])
+  emitBlock(writer, declaration.body, "\t", path + "/body")
+  writer.mapped("}", {mappingKind: "anchor", node: declaration, path})
+  writer.synthetic("\n", "line break", [declaration], [path])
+}
+
+/**
+ * Emits an ordered block.
+ * @param {SourceWriter} writer Source-aware writer.
+ * @param {import("../semantic/types.js").Block} block Semantic block.
+ * @param {string} indent Current indentation.
+ * @param {string} path Semantic path.
+ * @returns {void}
+ */
+function emitBlock(writer, block, indent, path) {
+  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, path + "/statements/" + index))
+}
+
+/**
+ * Emits one supported statement.
+ * @param {SourceWriter} writer Source-aware writer.
+ * @param {import("../semantic/types.js").Statement} statement Semantic statement.
+ * @param {string} indent Current indentation.
+ * @param {string} path Semantic path.
+ * @returns {void}
+ */
+function emitStatement(writer, statement, indent, path) {
+  if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") {
+    return emitLocal(writer, statement, indent, path)
+  }
+  if (statement.kind == "IfStatement") return emitIf(writer, statement, indent, path, true)
+  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", "go", identity)
+  } else {
+    writer.mapped("fmt.Println", {mappingKind: "anchor", node: statement, path})
+    writer.mapped("(", {mappingKind: "anchor", node: statement, path})
+    emitExpression(writer, statement.expression, path + "/expression", "go", identity)
+    writer.mapped(")", {mappingKind: "anchor", node: statement, path})
+  }
+  writer.synthetic("\n", "line break", [statement], [path])
+}
+
+/**
+ * Emits a conditional, using direct else-if for the canonical nested shape.
+ * @param {SourceWriter} writer Source-aware writer.
+ * @param {import("../semantic/types.js").IfStatement} statement Conditional.
+ * @param {string} indent Current indentation.
+ * @param {string} path Semantic path.
+ * @param {boolean} includeIndent Whether to emit leading indentation.
+ * @returns {void}
+ */
+function emitIf(writer, statement, indent, path, includeIndent) {
+  if (includeIndent) writer.synthetic(indent, "indentation", [statement], [path])
+  writer.mapped("if", {mappingKind: "anchor", node: statement, path})
+  writer.synthetic(" ", "conditional spacing", [statement], [path])
+  emitCondition(writer, statement.condition, path + "/condition")
+  writer.synthetic(" ", "conditional spacing", [statement], [path])
+  writer.mapped("{", {mappingKind: "anchor", node: statement.consequent, path: path + "/consequent"})
+  writer.synthetic("\n", "line break", [statement], [path])
+  emitBlock(writer, statement.consequent, indent + "\t", path + "/consequent")
+  writer.synthetic(indent, "indentation", [statement], [path])
+  writer.mapped("}", {mappingKind: "anchor", node: statement.consequent, path: path + "/consequent"})
+  if (statement.alternate) {
+    writer.synthetic(" ", "alternate spacing", [statement], [path])
+    writer.mapped("else", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "alternate spacing", [statement], [path])
+    const nested = statement.alternate.statements.length == 1 && statement.alternate.statements[0].kind == "IfStatement"
+
+    if (nested) {
+      emitIf(writer, /** @type {import("../semantic/types.js").IfStatement} */ (statement.alternate.statements[0]),
+        indent, path + "/alternate/statements/0", false)
+      return
+    }
+    writer.mapped("{", {mappingKind: "anchor", node: statement.alternate, path: path + "/alternate"})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.alternate, indent + "\t", path + "/alternate")
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("}", {mappingKind: "anchor", node: statement.alternate, path: path + "/alternate"})
+  }
+  writer.synthetic("\n", "line break", [statement], [path])
+}
+
+/**
+ * Emits a condition without the one redundant outer pair removed by gofmt.
+ * Child operations stay parenthesized so the semantic tree round-trips exactly.
+ * @param {SourceWriter} writer Source-aware writer.
+ * @param {import("../semantic/types.js").Expression} expression Condition expression.
+ * @param {string} path Semantic path.
+ * @returns {void}
+ */
+function emitCondition(writer, expression, path) {
+  if (expression.kind == "BinaryExpression") {
+    emitExpression(writer, expression.left, path + "/left", "go", identity)
+    writer.synthetic(" ", "operator spacing", [expression], [path])
+    writer.mapped(binarySyntax[expression.operation], {mappingKind: "exact", node: expression, path, role: "operator"})
+    writer.synthetic(" ", "operator spacing", [expression], [path])
+    emitExpression(writer, expression.right, path + "/right", "go", identity)
+    return
+  }
+  if (expression.kind == "UnaryExpression") {
+    writer.mapped(expression.operation == "BooleanNot" ? "!" : "-", {
+      mappingKind: "exact", node: expression, path, role: "operator"
+    })
+    emitExpression(writer, expression.operand, path + "/operand", "go", identity)
+    return
+  }
+  emitExpression(writer, expression, path, "go", identity)
+}
+
+/**
+ * Emits a local declaration or assignment.
+ * @param {SourceWriter} writer Source-aware writer.
+ * @param {import("../semantic/types.js").LocalStatement} statement Local statement.
+ * @param {string} indent Current indentation.
+ * @param {string} path Semantic path.
+ * @returns {void}
+ */
+function emitLocal(writer, statement, indent, path) {
+  if (statement.kind == "LocalDeclaration" && !statement.mutable) {
+    writer.synthetic(indent + "// @semantifold-immutable\n", "Go 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", "go", identity)
+  } else {
+    writer.mapped("var", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "declaration spacing", [statement], [path])
+    writer.mapped(statement.name, {mappingKind: "exact", node: statement, path, role: "name"})
+    writer.synthetic(" ", "declaration spacing", [statement], [path])
+    writer.mapped(emitScalarType("go", 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", "go", identity)
+  }
+  writer.synthetic("\n", "line break", [statement], [path])
+}
+
+/**
+ * Converts root provenance to artifact-level related origins.
+ * @param {import("../semantic/types.js").SemanticNodeProvenance} root Root provenance.
+ * @returns {import("../semantic/types.js").RelatedOrigin[]} Related roots.
+ */
+function relatedRootOrigins(root) {
+  if (root.origin.kind == "source") {
+    return [{location: root.origin.location, nodeId: root.id, role: "module", sourceId: root.origin.sourceId}]
+  }
+  const origins = root.origin.kind == "derived" ? root.origin.origins : root.origin.relatedOrigins
+
+  return origins.map((origin) => ({...origin, nodeId: origin.nodeId ?? root.id, role: origin.role ?? "module"}))
+}
+
+/**
+ * Preserves an already validated Go identifier.
+ * @param {string} name Identifier.
+ * @returns {string} Unchanged spelling.
+ */
+function identity(name) {
+  return name
+}

package/src/backends/identifiers.js

@@ -4,15 +4,65 @@ import {unsupportedCapability} from "../diagnostic.js"
 
 /** @type {Record<import("../semantic/types.js").SemanticLanguage, RegExp>} */
 const identifierPatterns = {
+  cpp: /^[A-Za-z][A-Za-z0-9_]*$/u,
+  c: /^[A-Za-z][A-Za-z0-9_]*$/u,
+  csharp: /^[A-Za-z_][A-Za-z0-9_]*$/u,
+  go: /^[A-Za-z_][A-Za-z0-9_]*$/u,
   java: /^[A-Za-z_$][A-Za-z0-9_$]*$/u,
   javascript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u,
   php: /^[A-Za-z_][A-Za-z0-9_]*$/u,
+  python: /^(?:_|\p{XID_Start})(?:_|\p{XID_Continue})*$/u,
   ruby: /^[a-z_][A-Za-z0-9_]*$/u,
   typescript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u
 }
 
 /** @type {Record<import("../semantic/types.js").SemanticLanguage, Set<string>>} */
 const reservedWords = {
+  cpp: new Set([
+    "alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand", "bitor", "bool", "break", "case", "catch", "char", "char8_t", "char16_t", "char32_t", "class", "compl", "concept", "const", "consteval", "constexpr", "constinit", "const_cast", "continue", "co_await", "co_return", "co_yield", "decltype", "default", "delete", "do", "double", "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", "float", "for", "friend", "goto", "if", "inline", "int", "long", "mutable", "namespace", "new", "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast", "requires", "return", "short", "signed", "sizeof", "static", "static_assert", "static_cast", "struct", "switch", "template", "this", "thread_local", "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq", "std", "string", "numeric_limits",
+    // The qualified libstdc++ <string> include chain also exposes these global names.
+    "WEOF", "wint_t"
+  ]),
+  c: new Set([
+    "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern",
+    "float", "for", "goto", "if", "inline", "int", "long", "register", "restrict", "return", "short", "signed",
+    "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while",
+    "bool", "true", "false", "TRUE", "FALSE", "int64_t", "uint64_t", "size_t", "ptrdiff_t", "main", "NULL", "INT64_C", "UINT64_C",
+    "INT64_MIN", "INT64_MAX", "PTRDIFF_MAX", "CHAR_BIT", "stdin", "stdout", "stderr", "malloc", "free", "exit",
+    "fwrite", "fflush", "memcpy", "memcmp", "FILE", "fpos_t", "div_t", "ldiv_t", "lldiv_t", "wchar_t", "max_align_t",
+    "offsetof", "alignas", "alignof", "noreturn", "true", "false", "assert", "static_assert", "errno",
+    "EOF", "BUFSIZ", "FOPEN_MAX", "FILENAME_MAX", "L_tmpnam", "SEEK_CUR", "SEEK_END", "SEEK_SET", "TMP_MAX",
+    "EXIT_FAILURE", "EXIT_SUCCESS", "MB_CUR_MAX", "MB_LEN_MAX", "RAND_MAX",
+    "remove", "rename", "tmpfile", "tmpnam", "fclose", "fopen", "freopen", "setbuf", "setvbuf",
+    "fprintf", "fscanf", "printf", "scanf", "snprintf", "sprintf", "sscanf", "vfprintf", "vfscanf", "vprintf",
+    "vscanf", "vsnprintf", "vsprintf", "vsscanf", "fgetc", "fgets", "fputc", "fputs", "getc", "getchar",
+    "putc", "putchar", "puts", "ungetc", "fread", "fgetpos", "fseek", "fsetpos", "ftell", "rewind", "clearerr",
+    "feof", "ferror", "perror", "atof", "atoi", "atol", "atoll", "strtod", "strtof", "strtold", "strtol",
+    "strtoll", "strtoul", "strtoull", "rand", "srand", "aligned_alloc", "calloc", "realloc", "abort", "atexit",
+    "at_quick_exit", "quick_exit", "getenv", "system", "bsearch", "qsort", "abs", "labs", "llabs", "div", "ldiv",
+    "lldiv", "mblen", "mbtowc", "wctomb", "mbstowcs", "wcstombs", "memmove", "strcpy", "strncpy", "strcat",
+    "strncat", "strcmp", "strcoll", "strncmp", "strxfrm", "memchr", "strchr", "strcspn", "strpbrk", "strrchr",
+    "strspn", "strstr", "strtok", "memset", "strerror", "strlen"
+  ]),
+  csharp: new Set([
+    "__arglist", "__makeref", "__reftype", "__refvalue", "abstract", "add", "alias", "allows", "and", "as",
+    "ascending", "async", "await", "base", "bool", "break",
+    "by", "byte", "case", "catch", "char", "checked", "class", "const", "continue", "decimal", "default",
+    "delegate", "descending", "do", "double", "dynamic", "else", "enum", "equals", "event", "explicit", "extension", "extern",
+    "false", "field", "file", "finally", "fixed", "float", "for", "foreach", "from", "get", "global", "goto",
+    "group", "if", "implicit", "in", "init", "int", "interface", "internal", "into", "is", "join", "let", "lock",
+    "long", "managed", "nameof", "namespace", "new", "nint", "not", "notnull", "null", "nuint", "object", "on",
+    "operator", "or", "orderby", "out", "override", "params", "partial", "private", "protected", "public", "readonly",
+    "record", "ref", "remove", "required", "return", "sbyte", "scoped", "sealed", "select", "set", "short", "sizeof",
+    "stackalloc", "static", "string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong",
+    "unchecked", "unmanaged", "unsafe", "ushort", "using", "value", "var", "virtual", "void", "volatile", "when",
+    "where", "while", "with", "yield"
+  ]),
+  go: new Set([
+    "_", "break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", "chan",
+    "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue", "for",
+    "import", "return", "var"
+  ]),
   java: new Set([
     "_", "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue",
     "default", "do", "double", "else", "enum", "exports", "extends", "false", "final", "finally", "float", "for",
@@ -38,6 +88,12 @@ const reservedWords = {
     "require_once", "return", "self", "static", "switch", "throw", "trait", "true", "try", "unset", "use", "var",
     "void", "while", "xor", "yield"
   ]),
+  python: new Set([
+    "False", "None", "True", "and", "as", "assert", "async", "await", "bool", "break", "case", "class",
+    "continue", "def", "del", "elif", "else", "except", "exec", "finally", "for", "from", "global", "if",
+    "import", "in", "int", "is", "lambda", "match", "nonlocal", "not", "or", "pass", "print",
+    "raise", "return", "str", "try", "type", "while", "with", "yield", "_", "__debug__"
+  ]),
   ruby: new Set([
     "BEGIN", "END", "__ENCODING__", "__END__", "__FILE__", "__LINE__", "alias", "and", "begin", "break", "case",
     "class", "def", "defined?", "do", "else", "elsif", "end", "ensure", "false", "for", "if", "in", "module",
@@ -73,11 +129,25 @@ export function validateTargetIdentifier(language, name, role, location) {
 
   const reservedName = language == "php" ? name.toLowerCase() : name
 
-  if (!identifierPatterns[language].test(name) || reservedWords[language].has(reservedName)) {
+  if (!identifierPatterns[language].test(name) || reservedWords[language].has(reservedName) ||
+    language == "python" && name.normalize("NFKC") != name ||
+    language == "c" && !isCIdentifier(name) ||
+    language == "cpp" && !isCppIdentifier(name)) {
     unsupportedCapability(language, `${role} identifier '${name}'`, location)
   }
 }
 
+/**
+ * Protects the exact C header environment and implementation-reserved namespace in either direction.
+ * @param {string} name - Caller identifier.
+ * @returns {boolean} Whether the spelling is safe in the canonical translation unit.
+ */
+export function isCIdentifier(name) {
+  return identifierPatterns.c.test(name) && !reservedWords.c.has(name) &&
+    !/^(?:semantifold_|SEMANTIFOLD_|Semantifold|atomic_|INT[0-9_A-Z]|UINT[0-9_A-Z]|INTMAX_|UINTMAX_|SIZE_|PTRDIFF_|SIG_ATOMIC_|WCHAR_|WINT_|CHAR_|SCHAR_|UCHAR_|SHRT_|USHRT_|LONG_|ULONG_|LLONG_|ULLONG_)/u.test(name) &&
+    !/^(?:u?int(?:8|16|32|64|max|ptr|_least[0-9]+|_fast[0-9]+)_t)$/u.test(name)
+}
+
 /**
  * Validates a binding identifier against target restrictions beyond general identifier syntax.
  * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
@@ -99,3 +169,12 @@ export function validateTargetBindingIdentifier(language, name, role, location)
     unsupportedCapability(language, `${role} identifier '${name}'`, location)
   }
 }
+
+/**
+ * Protects C++ keywords, the actual included C library names/macros and the scaffold namespace.
+ * @param {string} name - Caller scalar binding or function name.
+ * @returns {boolean} Whether a canonical C++20 translation unit can represent the name.
+ */
+export function isCppIdentifier(name) {
+  return isCIdentifier(name) && !name.includes("__") && !reservedWords.cpp.has(name)
+}

package/src/backends/index.js

@@ -1,24 +1,12 @@
 // @ts-check
 
-import {SemantifoldDiagnostic, unsupportedCapability} from "../diagnostic.js"
-import {generateJava} from "./java.js"
-import {generateJavaScript} from "./javascript.js"
-import {generatePhp} from "./php.js"
-import {generateRuby} from "./ruby.js"
+import {unsupportedCapability, unsupportedRole} from "../diagnostic.js"
+import {isValidFilenameMetadata} from "../artifact-path.js"
+import {languageRegistry} from "../language-registry.js"
+import {validateNativeGraph} from "./native-validation.js"
 import {validateBackendModule} from "./shared.js"
-import {generateTypeScript} from "./typescript.js"
 import {SourceWriter} from "./writer.js"
 import {finalizeMapping, toSourceMapV3} from "../mapping.js"
-
-/** @type {Readonly<Record<import("../semantic/types.js").SemanticLanguage, string>>} */
-const defaultFilenames = Object.freeze({
-  java: "Main.java",
-  javascript: "program.js",
-  php: "program.php",
-  ruby: "program.rb",
-  typescript: "program.ts"
-})
-const lineTerminatorPattern = /[\n\r\u2028\u2029]/u
 const syntheticArtifactBase = Object.freeze(["__semantifold_artifacts__"])
 
 /**
@@ -43,18 +31,33 @@ export function generateSource({language, module}) {
  * @param {{filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]} [input.sources] - Source content for legacy or assembled modules.
  * @returns {import("../semantic/types.js").GeneratedArtifact} Generated artifact.
  */
-export function generateArtifactSource({language, filename = defaultFilenames[language], mapDirective = "none", module, sourceMapFilename = `${filename}.map`, sources}) {
+export function generateArtifactSource({language, filename, mapDirective = "none", module, sourceMapFilename, sources}) {
+  const backend = languageRegistry.resolve(language, "textBackend", module?.location)
+  const record = languageRegistry.record(language)
+
+  if (record.artifactMultiplicity != "single") unsupportedRole(language, "single-text backend", module?.location)
+  if (filename === undefined) filename = record.defaultFilename
+  if (sourceMapFilename === undefined) sourceMapFilename = `${filename}.map`
+  if (language == "cpp") validateNativeGraph(module, "cpp")
   validateBackendModule(module, language)
 
-  if (typeof filename != "string" || filename.length == 0 || lineTerminatorPattern.test(filename)) {
+  if (language == "cpp" && (mapDirective != "none" || sourceMapFilename != "program.cpp.map")) {
+    unsupportedCapability(language, "CPP map directive or alternate source-map filename", module.location)
+  }
+
+  if (!isValidFilenameMetadata(filename)) {
     throw new TypeError("Generated filename must be a non-empty single-line string.")
   }
-  if (typeof sourceMapFilename != "string" || sourceMapFilename.length == 0 || lineTerminatorPattern.test(sourceMapFilename)) {
+  if (!isValidFilenameMetadata(sourceMapFilename)) {
     throw new TypeError("Source map filename must be a non-empty single-line string.")
   }
+  if (language == "cpp" && filename != "program.cpp") unsupportedCapability(language, "artifact filename other than program.cpp", module.location)
   if (language == "java" && filename.split(/[\\/]/u).at(-1) != "Main.java") {
     unsupportedCapability(language, "artifact filename basename other than Main.java", module.location)
   }
+  if (language == "python" && filename.split(/[\\/]/u).at(-1) != "program.py") {
+    unsupportedCapability(language, "artifact filename basename other than program.py", module.location)
+  }
   if (!["none", "external", "inline"].includes(mapDirective)) throw new TypeError(`Unsupported map directive: ${mapDirective}`)
   if (mapDirective != "none" && language != "javascript" && language != "typescript") {
     throw new TypeError("Source map directives are supported only for JavaScript and TypeScript outputs.")
@@ -62,19 +65,7 @@ export function generateArtifactSource({language, filename = defaultFilenames[la
 
   const writer = new SourceWriter({filename, language, module, sources})
 
-  if (language == "php") generatePhp(module, writer)
-  else if (language == "ruby") generateRuby(module, writer)
-  else if (language == "javascript") generateJavaScript(module, writer)
-  else if (language == "typescript") generateTypeScript(module, writer)
-  else if (language == "java") generateJava(module, writer)
-  else {
-    throw new SemantifoldDiagnostic({
-      code: "UNSUPPORTED_LANGUAGE",
-      language,
-      location: module.location,
-      message: "No source backend is registered for this language."
-    })
-  }
+  backend(module, writer)
 
   const sourceMap = toSourceMapV3(writer.finish())
 

package/src/backends/native-validation.js

@@ -0,0 +1,64 @@
+// @ts-check
+
+import {unsupportedCapability} from "../diagnostic.js"
+
+/** @typedef {import("../semantic/types.js").SourceLocation} SourceLocation */
+
+const semanticEdges = new Set(["functions", "entryPoint", "body", "parameters", "returnType", "statements", "condition",
+  "consequent", "alternate", "type", "target", "initializer", "expression", "operand", "left", "right", "arguments"])
+
+/**
+ * Bounds a native occurrence plan and rejects cycles before recursive shared validation.
+ * @param {unknown} module - Untrusted backend request.
+ * @param {"c" | "cpp"} [language] - Native backend diagnostic language.
+ * @returns {void}
+ */
+export function validateNativeGraph(module, language = "c") {
+  const active = new Set()
+  const weights = new Map()
+
+  /**
+   * Counts expanded semantic occurrences while memoizing shared objects.
+   * @param {unknown} value - Candidate semantic value.
+   * @param {number} depth - Traversal depth.
+   * @returns {number} Bounded expanded weight.
+   */
+  function visit(value, depth) {
+    if (!value || typeof value != "object") return 0
+    const location = /** @type {{location?: SourceLocation}} */ (value).location
+    const kind = /** @type {{kind?: string}} */ (value).kind
+
+    if (!Array.isArray(value) && (kind != "TypeReference" || "location" in value) && !validLocation(location)) {
+      unsupportedCapability(language, "missing or invalid semantic location", undefined)
+    }
+
+    if (depth > 512 || active.has(value)) unsupportedCapability(language, "cyclic or excessively nested semantic graph", location)
+    if (weights.has(value)) return weights.get(value)
+    active.add(value)
+    let size = 1
+    const children = Array.isArray(value) ? value : Object.entries(value).filter(([key]) => semanticEdges.has(key)).map(([, child]) => child)
+
+    for (const child of children) {
+      size += visit(child, depth + 1)
+      if (size > 999999) unsupportedCapability(language, "expanded native occurrence plan exceeds six-digit capacity", location)
+    }
+    active.delete(value)
+    weights.set(value, size)
+    return size
+  }
+
+  visit(module, 0)
+}
+
+/**
+ * Checks required semantic coordinates before the provenance writer reads them.
+ * @param {SourceLocation | undefined} location - Candidate origin.
+ * @returns {boolean} Whether it is a complete ordered UTF-16 range.
+ */
+function validLocation(location) {
+  return Boolean(location && typeof location.filename == "string" && location.filename.length > 0 &&
+    [location.start, location.end].every((point) => point && Number.isSafeInteger(point.offset) && point.offset >= 0 &&
+      Number.isSafeInteger(point.line) && point.line >= 1 && Number.isSafeInteger(point.column) && point.column >= 1) &&
+    location.end.offset >= location.start.offset && location.end.line >= location.start.line &&
+    (location.end.line != location.start.line || location.end.column >= location.start.column))
+}