semantifold 0.5.0 → 0.7.0

package/src/backends/identifiers.js

@@ -2,13 +2,14 @@
 
 import {unsupportedCapability} from "../diagnostic.js"
 
-/** @type {Record<Exclude<import("../semantic/types.js").BackendLanguage, "ios">, RegExp>} */
+/** @type {Record<Exclude<import("../semantic/types.js").BackendLanguage, "ios" | "flutter">, RegExp>} */
 const identifierPatterns = {
   android: /^(?:_|\p{L})(?:_|\p{L}|\p{Nd})*$/u,
   dart: /^(?:_|\p{L})(?:_|\p{L}|\p{Nd})*$/u,
   kotlin: /^(?:_|\p{L})(?:_|\p{L}|\p{Nd})*$/u,
   swift: /^(?:_|\p{XID_Start})(?:_|\p{XID_Continue})*$/u,
   rust: /^[A-Za-z_][A-Za-z0-9_]*$/u,
+  zig: /^[A-Za-z_][A-Za-z0-9_]*$/u,
   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,
@@ -22,7 +23,7 @@ const identifierPatterns = {
   wasm: /^(?:[$_]|\p{XID_Start})(?:[$_]|\p{XID_Continue})*$/u
 }
 
-/** @type {Record<Exclude<import("../semantic/types.js").BackendLanguage, "ios">, Set<string>>} */
+/** @type {Record<Exclude<import("../semantic/types.js").BackendLanguage, "ios" | "flutter">, Set<string>>} */
 const reservedWords = {
   android: new Set([
     "as", "break", "class", "continue", "do", "else", "false", "for", "fun", "if", "in", "interface", "is", "null",
@@ -60,6 +61,18 @@ const reservedWords = {
     "unsafe", "use", "where", "while", "abstract", "become", "box", "do", "final", "macro", "override", "priv", "typeof", "unsized", "virtual",
     "yield", "try", "union", "_", "main", "String", "std", "i64", "bool"
   ]),
+  zig: new Set([
+    "addrspace", "align", "allowzero", "and", "anyerror", "anyframe", "anyopaque", "anytype", "asm", "async", "await", "break", "callconv",
+    "catch", "comptime", "const", "continue", "defer", "else", "enum", "errdefer", "error", "export", "extern", "false",
+    "fn", "for", "if", "inline", "linksection", "noalias", "noinline", "nosuspend", "null", "opaque", "or", "orelse",
+    "packed", "pub", "resume", "return", "struct", "suspend", "switch", "test", "threadlocal", "true", "try", "union",
+    "unreachable", "usingnamespace", "var", "volatile", "while", "_", "main", "std", "bool", "c_char", "c_int", "c_long",
+    "c_longdouble", "c_longlong", "c_short", "c_uint", "c_ulong", "c_ulonglong", "c_ushort", "comptime_float",
+    "comptime_int", "f16", "f32", "f64", "f80", "f128", "isize", "noreturn", "type", "undefined", "usize", "void",
+    "semantifold_arena", "semantifold_fail", "semantifold_integer_add", "semantifold_integer_subtract",
+    "semantifold_integer_multiply", "semantifold_integer_negate", "semantifold_string_concat", "semantifold_string_equal",
+    "semantifold_string_not_equal", "semantifold_print_integer", "semantifold_print_boolean", "semantifold_print_string"
+  ]),
   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.
@@ -223,12 +236,13 @@ export function validateTargetIdentifier(language, name, role, location) {
   if (typeof name != "string") unsupportedCapability(language, `${role} identifier`, location)
 
   const reservedName = language == "php" ? name.toLowerCase() : name
-  const syntaxLanguage = language == "ios" ? "swift" : language
+  const syntaxLanguage = language == "ios" ? "swift" : language == "flutter" ? "dart" : language
 
   if (!identifierPatterns[syntaxLanguage].test(name) || reservedWords[syntaxLanguage].has(reservedName) ||
     language == "python" && name.normalize("NFKC") != name ||
     language == "c" && !isCIdentifier(name) ||
     language == "rust" && !isRustIdentifier(name) ||
+    language == "zig" && !isZigIdentifier(name) ||
     language == "cpp" && !isCppIdentifier(name) ||
     language == "dart" && !isDartIdentifier(name) ||
     language == "swift" && (!isSwiftIdentifier(name) || name.normalize("NFC") != name) ||
@@ -282,7 +296,7 @@ export function validateTargetTypeIdentifier(language, name, location) {
     unsupportedCapability(language, `record type identifier '${String(name)}'`, location)
   }
   const reservedName = language == "php" ? name.toLowerCase() : name
-  const syntaxLanguage = language == "ios" ? "swift" : language
+  const syntaxLanguage = language == "ios" ? "swift" : language == "flutter" ? "dart" : language
 
   if (reservedWords[syntaxLanguage].has(reservedName) || reservedTypeNames[language]?.has(reservedName)) {
     unsupportedCapability(language, `record type identifier '${name}'`, location)
@@ -307,6 +321,16 @@ export function isRustIdentifier(name) {
   return identifierPatterns.rust.test(name) && !reservedWords.rust.has(name) && !name.startsWith("semantifold_")
 }
 
+/**
+ * Protects Zig keywords, scalar names, entry plumbing, builtins, and the support namespace.
+ * @param {string} name - Caller-owned function or binding name.
+ * @returns {boolean} Whether ordinary unquoted Zig syntax can preserve the name.
+ */
+export function isZigIdentifier(name) {
+  return identifierPatterns.zig.test(name) && !reservedWords.zig.has(name) && !/^[iu][0-9]+$/u.test(name) &&
+    !name.startsWith("semantifold_")
+}
+
 /**
  * Protects Swift keywords, scalar names, entry plumbing, and target-only helper names.
  * @param {string} name - Caller-owned function or binding name.

package/src/backends/ios.js

@@ -13,7 +13,7 @@ import {SourceWriter} from "./writer.js"
 
 /** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
 const iosSourceLanguages = new Set([
-  "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart"
+  "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart", "zig"
 ])
 const configurationFields = new Set([
   "bundleIdentifier", "capabilities", "deploymentTarget", "displayName", "entitlements", "infoPlist", "lifecycle",

package/src/backends/native-validation.js

@@ -10,7 +10,7 @@ const semanticEdges = new Set(["functions", "entryPoint", "body", "parameters",
 /**
  * Bounds a native occurrence plan and rejects cycles before recursive shared validation.
  * @param {unknown} module - Untrusted backend request.
- * @param {"c" | "cpp" | "kotlin" | "rust" | "swift" | "wasm"} [language] - Backend diagnostic language.
+ * @param {"c" | "cpp" | "kotlin" | "rust" | "swift" | "wasm" | "zig"} [language] - Backend diagnostic language.
  * @returns {void}
  */
 export function validateNativeGraph(module, language = "c") {

package/src/backends/program.js

@@ -23,7 +23,7 @@ import {programImportName, SourceWriter} from "./writer.js"
 /** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
 const programTargets = new Set(["php", "ruby", "javascript", "typescript", "java"])
 /** @type {Readonly<Set<import("../semantic/types.js").BackendLanguage>>} */
-const programApplicationTargets = new Set(["android", "ios"])
+const programApplicationTargets = new Set(["android", "ios", "flutter"])
 
 /**
  * Validates and prepares a complete semantic program for a non-text backend without allocating a writer.
@@ -68,8 +68,8 @@ export function preflightSemanticProgram({backendLanguage, diagnosticLanguage, p
  * @param {import("../semantic/types.js").BackendLanguage} input.language - Registered program target.
  * @param {import("../semantic/types.js").SemanticProgram} input.program - Complete semantic program.
  * @param {"text" | "application"} [input.role] - Explicit artifact role; omitted preserves text generation.
- * @param {import("../semantic/types.js").IosApplicationConfigurationInput | import("../semantic/types.js").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.
- * @param {import("../semantic/types.js").IosApplicationAssetInput[] | import("../semantic/types.js").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.
+ * @param {import("../semantic/types.js").IosApplicationConfigurationInput | import("../semantic/types.js").AndroidApplicationConfigurationInput | import("../semantic/types.js").FlutterApplicationConfigurationInput} [input.configuration] - Application configuration.
+ * @param {import("../semantic/types.js").IosApplicationAssetInput[] | import("../semantic/types.js").AndroidApplicationInputFile[] | import("../semantic/types.js").FlutterApplicationAssetInput[]} [input.assets] - Exact caller assets.
  * @param {import("../semantic/types.js").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.
  * @returns {import("../semantic/types.js").GeneratedArtifactSet} Transactionally validated artifact set.
  */

package/src/backends/scalars.js

@@ -2,6 +2,7 @@
 
 /** @type {Readonly<Record<import("../semantic/types.js").TextBackendLanguage, Readonly<Record<import("../semantic/types.js").FunctionReturnTypeName, string>>>>} */
 const targetScalarTypes = Object.freeze({
+  zig: Object.freeze({boolean: "bool", integer: "i64", string: "[]const u8", void: "void"}),
   dart: Object.freeze({boolean: "bool", integer: "int", string: "String", void: "void"}),
   swift: Object.freeze({boolean: "Bool", integer: "Int64", string: "String", void: "Void"}),
   rust: Object.freeze({boolean: "bool", integer: "i64", string: "String", void: "()"}),

package/src/backends/shared.js

@@ -27,7 +27,7 @@ const binaryOperationSyntax = Object.freeze({
   StringEqual: Object.freeze({default: "==", strict: "==="}),
   StringNotEqual: Object.freeze({default: "!=", strict: "!=="})
 })
-const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "dart"])
+const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "dart", "zig"])
 const task006Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task007Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task008Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
@@ -1952,9 +1952,9 @@ function validateKnownTargetInteger(expression, language, location) {
   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" || language == "rust" || language == "swift" || language == "wasm") && value !== undefined &&
+  if ((language == "csharp" || language == "go" || language == "c" || language == "cpp" || language == "rust" || language == "swift" || language == "wasm" || language == "zig") && value !== undefined &&
     (value < -9223372036854775808n || value > 9223372036854775807n)) {
-    const scalar = language == "wasm" ? "i64" : language == "swift" ? "Int64" : "long"
+    const scalar = language == "wasm" || language == "zig" ? "i64" : language == "swift" ? "Int64" : "long"
 
     unsupportedCapability(language, `compile-time-known integer operation outside signed 64-bit ${scalar} range`, location)
   }
@@ -2241,7 +2241,8 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
     return
   }
   if (expression.kind == "CallExpression") {
-    const dartMultiline = language == "dart" && expression.arguments.length > 0 &&
+    const callArgumentSuffix = writer.callArgumentSuffixFor(expression)
+    const dartMultiline = language == "dart" && (expression.arguments.length > 0 || Boolean(callArgumentSuffix)) &&
       dartExpressionExceedsPageWidth(writer, expression)
     const dartIndent = dartMultiline ? currentLineIndent(writer) : ""
 
@@ -2255,11 +2256,10 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
       emitExpression(writer, argument, `${path}/arguments/${index}`, language, emitIdentifier)
       if (dartMultiline) writer.synthetic(",\n", "Dart formatter argument separator", [expression], [path])
     })
-    const callArgumentSuffix = writer.callArgumentSuffixFor(expression)
-
     if (callArgumentSuffix) {
-      writer.synthetic(`${expression.arguments.length ? ", " : ""}${callArgumentSuffix}`,
-        "target-container semantic call argument", [expression], [path])
+      writer.synthetic(dartMultiline ? `${expression.arguments.length ? "" : "\n"}${dartIndent}  ${callArgumentSuffix},\n` :
+        `${expression.arguments.length ? ", " : ""}${callArgumentSuffix}`,
+      "target-container semantic call argument", [expression], [path])
     }
     if (dartMultiline) writer.synthetic(dartIndent, "Dart call closing indentation", [expression], [path])
     writer.mapped(")", {mappingKind: "anchor", node: expression, path})
@@ -2558,14 +2558,18 @@ function currentLineIndent(writer) {
  * @param {import("../semantic/types.js").Expression} expression Semantic expression.
  * @returns {string} Flat canonical spelling.
  */
-function flatDartExpression(writer, expression) {
+export function flatDartExpression(writer, expression) {
   if (expression.kind == "IdentifierExpression") return expression.name
   if (expression.kind == "IntegerLiteral") return String(expression.value)
   if (expression.kind == "BooleanLiteral") return `_semantifoldBoolean(${expression.value ? "true" : "false"})`
   if (expression.kind == "StringLiteral") return emitStringLiteral("dart", expression.value)
   if (expression.kind == "CallExpression") {
-    return `${writer.callNameFor(expression)}(${expression.arguments.map((argument) =>
-      flatDartExpression(writer, argument)).join(", ")})`
+    const arguments_ = expression.arguments.map((argument) => flatDartExpression(writer, argument))
+    const callArgumentSuffix = writer.callArgumentSuffixFor(expression)
+
+    if (callArgumentSuffix) arguments_.push(callArgumentSuffix)
+
+    return `${writer.callNameFor(expression)}(${arguments_.join(", ")})`
   }
   if (expression.kind == "UnaryExpression") {
     const operand = flatDartExpression(writer, expression.operand)

package/src/backends/zig-runtime.js

@@ -0,0 +1,93 @@
+// @ts-check
+
+/** Exact Zig 0.15.2 standard-library-only support; the frontend checks every token before collapse. */
+export const zigRuntime = `const std = @import("std");
+
+var semantifold_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+
+fn semantifold_fail(message: []const u8) noreturn {
+    std.fs.File.stderr().writeAll(message) catch {};
+    std.process.exit(70);
+}
+
+fn semantifold_integer_add(left: i64, right: i64) i64 {
+    const result = @addWithOverflow(left, right);
+    if (result[1] != 0) semantifold_fail("semantifold: integer overflow\\n");
+    return result[0];
+}
+
+fn semantifold_integer_subtract(left: i64, right: i64) i64 {
+    const result = @subWithOverflow(left, right);
+    if (result[1] != 0) semantifold_fail("semantifold: integer overflow\\n");
+    return result[0];
+}
+
+fn semantifold_integer_multiply(left: i64, right: i64) i64 {
+    const result = @mulWithOverflow(left, right);
+    if (result[1] != 0) semantifold_fail("semantifold: integer overflow\\n");
+    return result[0];
+}
+
+fn semantifold_integer_negate(value: i64) i64 {
+    return semantifold_integer_subtract(0, value);
+}
+
+fn semantifold_string_concat(left: []const u8, right: []const u8) []const u8 {
+    const size = @addWithOverflow(left.len, right.len);
+    if (size[1] != 0) semantifold_fail("semantifold: allocation failure\\n");
+    const bytes = semantifold_arena.allocator().alloc(u8, size[0]) catch semantifold_fail("semantifold: allocation failure\\n");
+    @memcpy(bytes[0..left.len], left);
+    @memcpy(bytes[left.len..], right);
+    return bytes;
+}
+
+fn semantifold_string_equal(left: []const u8, right: []const u8) bool {
+    return std.mem.eql(u8, left, right);
+}
+
+fn semantifold_string_not_equal(left: []const u8, right: []const u8) bool {
+    return !std.mem.eql(u8, left, right);
+}
+
+fn semantifold_write(value: []const u8) void {
+    const stdout = std.fs.File.stdout();
+    stdout.writeAll(value) catch semantifold_fail("semantifold: output failure\\n");
+    stdout.writeAll("\\n") catch semantifold_fail("semantifold: output failure\\n");
+}
+
+fn semantifold_print_integer(value: i64) void {
+    var buffer: [20]u8 = undefined;
+    const bytes = std.fmt.bufPrint(&buffer, "{d}", .{value}) catch semantifold_fail("semantifold: output failure\\n");
+    semantifold_write(bytes);
+}
+
+fn semantifold_print_boolean(value: bool) void {
+    semantifold_write(if (value) "true" else "false");
+}
+
+fn semantifold_print_string(value: []const u8) void {
+    semantifold_write(value);
+}
+`
+
+/** Fixed native-host Zig build with only the selected optimization option and no package resolution. */
+export const zigBuild = `const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const optimize = b.standardOptimizeOption(.{});
+    const executable = b.addExecutable(.{
+        .name = "semantifold-generated",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = b.graph.host,
+            .optimize = optimize,
+        }),
+    });
+    b.installArtifact(executable);
+
+    const tests = b.addTest(.{ .root_module = executable.root_module });
+    const run_tests = b.addRunArtifact(tests);
+    const test_step = b.step("test", "Compile and run tests");
+    test_step.dependOn(&run_tests.step);
+}
+`

package/src/backends/zig-validation.js

@@ -0,0 +1,68 @@
+// @ts-check
+
+import {unsupportedCapability} from "../diagnostic.js"
+
+/** Repository-owned bound for frozen CST traversal and deterministic project generation. */
+export const maximumZigSourceLength = 1_000_000
+
+/**
+ * Rejects statically impossible UTF-8 arena sizes without changing the semantic graph.
+ * @param {import("../semantic/types.js").SemanticModule} module - Fully validated module.
+ * @returns {void}
+ */
+export function validateZigValues(module) {
+  /**
+   * Infers a known UTF-8 byte size while validating literal shape.
+   * @param {import("../semantic/types.js").Expression} expression - Expression to inspect.
+   * @param {Map<string, bigint | undefined>} sizes - Known binding sizes.
+   * @returns {bigint | undefined} Known byte size when statically available.
+   */
+  const size = (expression, sizes) => {
+    if (expression.kind == "IntegerLiteral" && (!Number.isSafeInteger(expression.value) || expression.value < 0 || Object.is(expression.value, -0))) {
+      unsupportedCapability("zig", "non-safe or noncanonical i64 literal", expression.location)
+    }
+    if (expression.kind == "StringLiteral") return BigInt(Buffer.byteLength(expression.value, "utf8"))
+    if (expression.kind == "IdentifierExpression") return sizes.get(expression.name)
+    if (expression.kind == "CallExpression") expression.arguments.forEach(argument => size(argument, sizes))
+    else if (expression.kind == "UnaryExpression") size(expression.operand, sizes)
+    else if (expression.kind == "BinaryExpression") {
+      const left = size(expression.left, sizes)
+      const right = size(expression.right, sizes)
+
+      if (expression.operation == "StringConcat") {
+        if ((left ?? 0n) + (right ?? 0n) > 9223372036854775807n) {
+          unsupportedCapability("zig", "known immutable UTF-8 slice exceeds the qualified native allocation limit", expression.location)
+        }
+        if (left !== undefined && right !== undefined) return left + right
+      }
+    }
+    return undefined
+  }
+  /**
+   * Propagates conservative known string sizes through one block.
+   * @param {import("../semantic/types.js").Block} block - Block to inspect.
+   * @param {Map<string, bigint | undefined>} inherited - Sizes visible on entry.
+   * @returns {Map<string, bigint | undefined>} Sizes known after the block.
+   */
+  const visit = (block, inherited) => {
+    const sizes = new Map(inherited)
+
+    for (const statement of block.statements) {
+      if (statement.kind == "LocalDeclaration") sizes.set(statement.name, size(statement.initializer, sizes))
+      else if (statement.kind == "AssignmentStatement") sizes.set(statement.target.name, size(statement.expression, sizes))
+      else if (statement.kind == "IfStatement") {
+        size(statement.condition, sizes)
+        const left = visit(statement.consequent, sizes)
+        const right = statement.alternate ? visit(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") {
+        if (statement.expression) size(statement.expression, sizes)
+      }
+    }
+    return sizes
+  }
+
+  for (const declaration of module.functions) visit(declaration.body, new Map())
+  visit(module.entryPoint.body, new Map())
+}