semantifold 0.3.0 → 0.5.0

package/build/src/backends/rust-runtime.js

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

package/build/src/backends/rust-validation.d.ts

@@ -0,0 +1,9 @@
+/** Qualified legacy Rust grammar input limit, including support source. */
+export declare const maximumRustSourceLength = 32767;
+/**
+ * Rejects statically unrepresentable owned values before constructing any artifacts.
+ * @param {import("../semantic/types.js").SemanticModule} module - Fully validated semantics.
+ * @returns {void}
+ */
+export declare function validateRustValues(module: import("../semantic/types.js").SemanticModule): void;
+//# sourceMappingURL=rust-validation.d.ts.map

package/build/src/backends/rust-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-validation.d.ts","sourceRoot":"","sources":["../../../src/backends/rust-validation.js"],"names":[],"mappings":"AAIA,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,QAAQ,CAAA;AA2D5C;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAH9B,OAAO,sBAAsB,EAAE,cAGD,GAF5B,IAAI,CAOhB"}

package/build/src/backends/rust-validation.js

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

package/build/src/backends/rust.d.ts

@@ -0,0 +1,24 @@
+export type SemanticModule = import("../semantic/types.js").SemanticModule;
+export type SemanticNode = import("../semantic/types.js").SemanticNode;
+export type Expression = import("../semantic/types.js").Expression;
+export type Scalar = import("../semantic/types.js").SemanticTypeName;
+/**
+ * Produces a complete deterministic offline Cargo project after full validation and size preflight.
+ * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Artifact-set request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Complete candidate set.
+ */
+export declare function generateRustProject({ filename, mapDirective, module, sourceMapFilename, sources }: {
+    filename?: string;
+    mapDirective?: unknown;
+    module: SemanticModule;
+    sourceMapFilename?: unknown;
+    sources?: {
+        filename: string;
+        content: string;
+        language?: import("../semantic/types.js").SemanticLanguage;
+    }[];
+}): {
+    artifacts: import("../semantic/types.js").GeneratedSetArtifact[];
+    target: string;
+};
+//# sourceMappingURL=rust.d.ts.map

package/build/src/backends/rust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust.d.ts","sourceRoot":"","sources":["../../../src/backends/rust.js"],"names":[],"mappings":"AAWI,YAAyD,cAAc,GAA7D,OAAO,sBAAsB,EAAE,cAAc,CAAgB;AACvE,YAAuD,YAAY,GAAzD,OAAO,sBAAsB,EAAE,YAAY,CAAc;AACnE,YAAqD,UAAU,GAArD,OAAO,sBAAsB,EAAE,UAAU,CAAY;AAC/D,YAA2D,MAAM,GAAvD,OAAO,sBAAsB,EAAE,gBAAgB,CAAQ;AAUrE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,EAHrF;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAAA;CAGvH,GAFnF;IAAC,SAAS,EAAE,OAAO,sBAAsB,EAAE,oBAAoB,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CA8B9F"}

package/build/src/backends/rust.js

@@ -0,0 +1,344 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+import { validateBackendModule } from "./shared.js";
+import { validateNativeGraph } from "./native-validation.js";
+import { maximumRustSourceLength, validateRustValues } from "./rust-validation.js";
+import { rustLockfile, rustManifest, rustRuntime } from "./rust-runtime.js";
+import { emitScalarType } from "./scalars.js";
+import { SourceWriter } from "./writer.js";
+/** @typedef {import("../semantic/types.js").SemanticModule} SemanticModule */
+/** @typedef {import("../semantic/types.js").SemanticNode} SemanticNode */
+/** @typedef {import("../semantic/types.js").Expression} Expression */
+/** @typedef {import("../semantic/types.js").SemanticTypeName} Scalar */
+const operators = new Map([
+    ["IntegerAdd", "semantifold_integer_add"], ["IntegerSubtract", "semantifold_integer_subtract"],
+    ["IntegerMultiply", "semantifold_integer_multiply"], ["IntegerEqual", "=="], ["IntegerNotEqual", "!="],
+    ["IntegerLessThan", "<"], ["IntegerLessThanOrEqual", "<="], ["IntegerGreaterThan", ">"], ["IntegerGreaterThanOrEqual", ">="],
+    ["BooleanEqual", "=="], ["BooleanNotEqual", "!="], ["BooleanAnd", "&&"], ["BooleanOr", "||"],
+    ["StringConcat", "+"], ["StringEqual", "=="], ["StringNotEqual", "!="]
+]);
+/**
+ * Produces a complete deterministic offline Cargo project after full validation and size preflight.
+ * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Artifact-set request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Complete candidate set.
+ */
+export function generateRustProject({ filename, mapDirective, module, sourceMapFilename, sources }) {
+    validateNativeGraph(module, "rust");
+    validateBackendModule(module, "rust");
+    validateRustValues(module);
+    if (filename !== undefined && filename != "src/main.rs")
+        unsupportedCapability("rust", "artifact filename other than src/main.rs", module.location);
+    if (mapDirective !== undefined || sourceMapFilename !== undefined)
+        unsupportedCapability("rust", "source-map filename or directive option", module.location);
+    new RustEmitter(module).program(module);
+    const writer = new SourceWriter({ filename: "src/main.rs", language: "rust", module, sources });
+    new RustEmitter(module, writer).program(module);
+    const mapping = finalizeMapping(writer.finish());
+    const root = mapping.nodes.find(node => node.path == "");
+    if (!root)
+        throw new Error("Validated Rust module omitted root provenance.");
+    const origin = root.origin;
+    const relatedOrigins = origin.kind == "source" ? [{ location: origin.location, nodeId: root.id, role: "module", sourceId: origin.sourceId }] :
+        (origin.kind == "derived" ? origin.origins : origin.relatedOrigins).map(item => ({ ...item, nodeId: item.nodeId ?? root.id, role: item.role ?? "module" }));
+    return { target: "rust", artifacts: [{
+                path: "Cargo.toml", role: "manifest", ownership: "generated", contentKind: "text", mediaType: "text/plain", content: rustManifest,
+                provenance: { kind: "synthetic", reason: "Fixed dependency-free edition-2021 Cargo package, Rust 1.98.1 minimum and matching dev/release abort/overflow profiles.", relatedOrigins }
+            }, {
+                path: "Cargo.lock", role: "support", ownership: "generated", contentKind: "text", mediaType: "text/plain", content: rustLockfile,
+                provenance: { kind: "synthetic", reason: "Exact dependency-free format-4 lockfile generated and qualified with Cargo 1.98.1.", relatedOrigins }
+            }, {
+                path: "src/main.rs", role: "entry", ownership: "generated", contentKind: "text", mediaType: "text/x-rust", content: mapping.generated.content,
+                provenance: { kind: "text", mapping, sourceMap: toSourceMapV3(mapping) }
+            }] };
+}
+/** Emits native left-to-right expressions with explicit owned String copy boundaries. */
+class RustEmitter {
+    /**
+     * Binds validated result types and an optional writer for the size-only preflight.
+     * @param {SemanticModule} module - Complete validated semantics.
+     * @param {SourceWriter} [writer] - Absent during size preflight.
+     */
+    constructor(module, writer) {
+        this.writer = writer;
+        /** @type {Map<string, Scalar>} */
+        this.functions = new Map(module.functions.map(declaration => [declaration.name, rustScalarType(declaration.returnType, declaration.location)]));
+        this.length = 0;
+        this.location = module.location;
+    }
+    /**
+     * Bounds exact source length before any public artifact or writer is exposed.
+     * @param {string} text - Next text chunk.
+     * @param {SemanticNode} node - Related semantic origin.
+     * @returns {void}
+     */
+    checkSize(text, node) {
+        this.length += text.length;
+        if (this.length > maximumRustSourceLength)
+            unsupportedCapability("rust", "generated program exceeds the frozen Rust parser's 32767 UTF-16 input limit", "location" in node ? node.location : this.location);
+    }
+    /**
+     * Emits target-owned syntax with explicit related semantic provenance.
+     * @param {string} text - Rust syntax.
+     * @param {SemanticNode} node - Related node.
+     * @param {string} path - Semantic occurrence.
+     * @param {string} [reason] - Synthetic syntax purpose.
+     * @returns {void}
+     */
+    synthetic(text, node, path, reason = "Rust declaration and expression syntax") {
+        this.checkSize(text, node);
+        this.writer?.synthetic(text, reason, [node], [path]);
+    }
+    /**
+     * Emits an original semantic token or declaration anchor.
+     * @param {string} text - Target token.
+     * @param {SemanticNode} node - Original node.
+     * @param {string} path - Occurrence path.
+     * @param {string} [role] - Original parser role.
+     * @returns {void}
+     */
+    mapped(text, node, path, role) {
+        this.checkSize(text, node);
+        this.writer?.mapped(text, { mappingKind: role ? "exact" : "anchor", node, path, ...(role ? { role } : {}) });
+    }
+    /**
+     * Resolves an already validated expression's native scalar representation.
+     * @param {Expression} expression - Validated expression.
+     * @param {Map<string, Scalar>} bindings - Lexical types.
+     * @returns {Scalar} Result scalar.
+     */
+    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;
+        if (expression.kind != "CallExpression" && expression.kind != "IdentifierExpression") {
+            return unsupportedCapability("rust", "collection expression reached scalar emission", expression.location);
+        }
+        const type = expression.kind == "CallExpression" ? this.functions.get(expression.callee) : bindings.get(expression.name);
+        if (!type)
+            throw new Error("Validated Rust expression lost its scalar type.");
+        return type;
+    }
+    /**
+     * Emits fixed support, crate-root functions and the parameterless entry point.
+     * @param {SemanticModule} module - Validated module.
+     * @returns {void}
+     */
+    program(module) {
+        this.synthetic(rustRuntime, module, "", "Exact Rust scalar, print and overflow support");
+        module.functions.forEach((declaration, index) => {
+            const path = `/functions/${index}`;
+            this.synthetic("\n", declaration, path);
+            this.mapped("fn", declaration, path);
+            this.synthetic(" ", declaration, path);
+            this.mapped(declaration.name, declaration, path, "name");
+            this.synthetic("(", declaration, path);
+            declaration.parameters.forEach((parameter, parameterIndex) => {
+                const parameterPath = `${path}/parameters/${parameterIndex}`;
+                if (parameterIndex)
+                    this.synthetic(", ", parameter, parameterPath);
+                this.mapped(parameter.name, parameter, parameterPath, "name");
+                this.synthetic(": ", parameter, parameterPath);
+                this.mapped(emitScalarType("rust", parameter.type), parameter.type, `${parameterPath}/type`, "type");
+            });
+            this.synthetic(") -> ", declaration, path);
+            this.mapped(emitScalarType("rust", declaration.returnType), declaration.returnType, `${path}/returnType`, "type");
+            this.synthetic(" {\n", declaration, path);
+            this.block(declaration.body, `${path}/body`, "    ", new Map(declaration.parameters.map(parameter => [
+                parameter.name, rustScalarType(parameter.type, parameter.location)
+            ])));
+            this.synthetic("}\n", declaration, path);
+        });
+        this.synthetic("\nfn main() {\n", module.entryPoint, "/entryPoint");
+        this.block(module.entryPoint.body, "/entryPoint/body", "    ", new Map());
+        this.synthetic("}\n", module.entryPoint, "/entryPoint");
+    }
+    /**
+     * Emits statements in order with independent branch binding environments.
+     * @param {import("../semantic/types.js").Block} block - Semantic block.
+     * @param {string} path - Occurrence path.
+     * @param {string} indent - Current indentation.
+     * @param {Map<string, Scalar>} inherited - Visible lexical types.
+     * @param {number} [depth] - Exact generated CST block depth, root source file at zero.
+     * @returns {void}
+     */
+    block(block, path, indent, inherited, depth = 2) {
+        if (depth + 1 > 512)
+            unsupportedCapability("rust", "generated Rust CST exceeds the 512-level traversal limit", block.location);
+        const bindings = new Map(inherited);
+        block.statements.forEach((statement, index) => {
+            this.statement(statement, `${path}/statements/${index}`, indent, bindings, depth);
+            if (statement.kind == "LocalDeclaration")
+                bindings.set(statement.name, rustScalarType(statement.type, statement.location));
+        });
+    }
+    /**
+     * Emits one semantic statement, copying String values except for terminal owned returns.
+     * @param {import("../semantic/types.js").Statement} statement - Statement.
+     * @param {string} path - Occurrence path.
+     * @param {string} indent - Indentation.
+     * @param {Map<string, Scalar>} bindings - Visible types.
+     * @param {number} depth - Enclosing generated CST block depth.
+     * @returns {void}
+     */
+    statement(statement, path, indent, bindings, depth) {
+        this.synthetic(indent, statement, path);
+        if (statement.kind == "ExpressionStatement")
+            throw new TypeError("Rust Task 005 expression statement reached emission.");
+        if (statement.kind == "LocalDeclaration") {
+            this.mapped(statement.mutable ? "let mut" : "let", statement, path);
+            this.synthetic(" ", statement, path);
+            this.mapped(statement.name, statement, path, "name");
+            this.synthetic(": ", statement, path);
+            this.mapped(emitScalarType("rust", statement.type), statement.type, `${path}/type`, "type");
+            this.synthetic(" ", statement, path);
+            this.mapped("=", statement, path, "operator");
+            this.synthetic(" ", statement, path);
+            this.expression(statement.initializer, `${path}/initializer`, bindings, true, depth + 2);
+        }
+        else if (statement.kind == "AssignmentStatement") {
+            this.mapped(statement.target.name, statement.target, `${path}/target`, "name");
+            this.synthetic(" ", statement, path);
+            this.mapped("=", statement, path, "operator");
+            this.synthetic(" ", statement, path);
+            this.expression(statement.expression, `${path}/expression`, bindings, true, depth + 3);
+        }
+        else if (statement.kind == "ReturnStatement") {
+            if (!statement.expression)
+                throw new TypeError("Rust bare return reached emission.");
+            this.mapped("return", statement, path);
+            this.synthetic(" ", statement, path);
+            this.expression(statement.expression, `${path}/expression`, bindings, false, depth + 3);
+        }
+        else if (statement.kind == "PrintStatement") {
+            this.mapped(`semantifold_print_${this.type(statement.expression, bindings)}`, statement, path);
+            this.synthetic("(", statement, path);
+            this.expression(statement.expression, `${path}/expression`, bindings, true, depth + 4);
+            this.synthetic(")", statement, path);
+        }
+        else if (statement.kind == "IfStatement") {
+            this.mapped("if", statement, path);
+            this.synthetic(" ", statement, path);
+            this.expression(statement.condition, `${path}/condition`, bindings, true, depth + 3);
+            this.synthetic(" {\n", statement, path);
+            this.block(statement.consequent, `${path}/consequent`, indent + "    ", bindings, depth + 3);
+            this.synthetic(indent + "}", statement, path);
+            if (statement.alternate) {
+                this.mapped(" else ", statement, path);
+                this.synthetic("{\n", statement, path);
+                this.block(statement.alternate, `${path}/alternate`, indent + "    ", bindings, depth + 4);
+                this.synthetic(indent + "}", statement, path);
+            }
+            this.synthetic("\n", statement, path);
+            return;
+        }
+        else {
+            throw new TypeError("Unsupported Rust statement reached emission.");
+        }
+        this.synthetic(";\n", statement, path);
+    }
+    /**
+     * Emits ordinary Rust left-to-right and short-circuit expressions without temporary reordering.
+     * @param {Expression} expression - Expression occurrence.
+     * @param {string} path - Occurrence path.
+     * @param {Map<string, Scalar>} bindings - Lexical types.
+     * @param {boolean} [copy] - Whether an identifier crosses an owned value-copy boundary.
+     * @param {number} [depth] - Exact generated CST expression depth.
+     * @returns {void}
+     */
+    expression(expression, path, bindings, copy = true, depth = 0) {
+        const leafDepth = expression.kind == "StringLiteral" ? 3 : expression.kind == "IdentifierExpression" && copy && this.type(expression, bindings) == "string" ? 2 :
+            expression.kind == "BooleanLiteral" ? 1 : 0;
+        if (depth + leafDepth > 512)
+            unsupportedCapability("rust", "generated Rust CST exceeds the 512-level traversal limit", expression.location);
+        if (expression.kind == "IdentifierExpression") {
+            this.mapped(expression.name, expression, path, "name");
+            if (copy && this.type(expression, bindings) == "string")
+                this.synthetic(".clone()", expression, path, "Owned String value copy");
+        }
+        else if (expression.kind == "BooleanLiteral")
+            this.mapped(String(expression.value), expression, path, "literal");
+        else if (expression.kind == "IntegerLiteral") {
+            this.mapped(String(expression.value), expression, path, "literal");
+            this.synthetic("i64", expression, path, "Exact signed-64-bit scalar suffix");
+        }
+        else if (expression.kind == "StringLiteral") {
+            this.synthetic("String::from(", expression, path, "Owned UTF-8 String construction");
+            let literal = '"';
+            for (const character of expression.value) {
+                const codePoint = /** @type {number} */ (character.codePointAt(0));
+                if (character == '"')
+                    literal += '\\"';
+                else if (character == "\\")
+                    literal += "\\\\";
+                else if (codePoint < 32 || codePoint == 127 || codePoint == 0x2028 || codePoint == 0x2029)
+                    literal += `\\u{${codePoint.toString(16)}}`;
+                else
+                    literal += character;
+            }
+            this.mapped(literal + '"', expression, path, "literal");
+            this.synthetic(")", expression, path, "Owned UTF-8 String construction");
+        }
+        else if (expression.kind == "CallExpression") {
+            this.mapped(expression.callee, expression, path, "callee");
+            this.synthetic("(", expression, path);
+            expression.arguments.forEach((argument, index) => {
+                if (index)
+                    this.synthetic(", ", expression, path);
+                this.expression(argument, `${path}/arguments/${index}`, bindings, true, depth + 2);
+            });
+            this.synthetic(")", expression, path);
+        }
+        else if (expression.kind == "UnaryExpression") {
+            this.mapped(expression.operation == "IntegerNegate" ? "semantifold_integer_negate" : "!", expression, path, "operator");
+            this.synthetic("(", expression, path);
+            this.expression(expression.operand, `${path}/operand`, bindings, true, depth + 2);
+            this.synthetic(")", expression, path);
+        }
+        else {
+            if (expression.kind != "BinaryExpression") {
+                return unsupportedCapability("rust", "collection expression reached scalar emission", expression.location);
+            }
+            const token = operators.get(expression.operation);
+            if (!token)
+                throw new Error("Unsupported operation passed Rust validation.");
+            const helper = token.startsWith("semantifold_");
+            const comparison = expression.operation == "StringEqual" || expression.operation == "StringNotEqual";
+            if (helper)
+                this.mapped(token, expression, path, "operator");
+            this.synthetic("(", expression, path);
+            this.expression(expression.left, `${path}/left`, bindings, !comparison, depth + 2);
+            if (helper)
+                this.synthetic(", ", expression, path);
+            else {
+                this.synthetic(" ", expression, path);
+                this.mapped(token, expression, path, "operator");
+                this.synthetic(" ", expression, path);
+            }
+            if (expression.operation == "StringConcat")
+                this.synthetic("&(", expression.right, `${path}/right`, "Borrowed String concatenation operand");
+            this.expression(expression.right, `${path}/right`, bindings, !comparison && expression.operation != "StringConcat", depth + (expression.operation == "StringConcat" ? 4 : 2));
+            if (expression.operation == "StringConcat")
+                this.synthetic(")", expression.right, `${path}/right`, "Borrowed String concatenation operand");
+            this.synthetic(")", expression, path);
+        }
+    }
+}
+/**
+ * Narrows a type after Rust collection capability rejection.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @param {import("../semantic/types.js").SourceLocation} location - Owning location.
+ * @returns {Scalar} Scalar type.
+ */
+function rustScalarType(type, location) {
+    if (type.kind != "TypeReference" || type.name == "void") {
+        return unsupportedCapability("rust", "collection or void type reached scalar emission", location);
+    }
+    return type.name;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust.js","sourceRoot":"","sources":["../../../src/backends/rust.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {unsupportedCapability} from \"../diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\nimport {validateBackendModule} from \"./shared.js\"\nimport {validateNativeGraph} from \"./native-validation.js\"\nimport {maximumRustSourceLength, validateRustValues} from \"./rust-validation.js\"\nimport {rustLockfile, rustManifest, rustRuntime} from \"./rust-runtime.js\"\nimport {emitScalarType} from \"./scalars.js\"\nimport {SourceWriter} from \"./writer.js\"\n\n/** @typedef {import(\"../semantic/types.js\").SemanticModule} SemanticModule */\n/** @typedef {import(\"../semantic/types.js\").SemanticNode} SemanticNode */\n/** @typedef {import(\"../semantic/types.js\").Expression} Expression */\n/** @typedef {import(\"../semantic/types.js\").SemanticTypeName} Scalar */\n\nconst operators = new Map([\n  [\"IntegerAdd\", \"semantifold_integer_add\"], [\"IntegerSubtract\", \"semantifold_integer_subtract\"],\n  [\"IntegerMultiply\", \"semantifold_integer_multiply\"], [\"IntegerEqual\", \"==\"], [\"IntegerNotEqual\", \"!=\"],\n  [\"IntegerLessThan\", \"<\"], [\"IntegerLessThanOrEqual\", \"<=\"], [\"IntegerGreaterThan\", \">\"], [\"IntegerGreaterThanOrEqual\", \">=\"],\n  [\"BooleanEqual\", \"==\"], [\"BooleanNotEqual\", \"!=\"], [\"BooleanAnd\", \"&&\"], [\"BooleanOr\", \"||\"],\n  [\"StringConcat\", \"+\"], [\"StringEqual\", \"==\"], [\"StringNotEqual\", \"!=\"]\n])\n\n/**\n * Produces a complete deterministic offline Cargo project after full validation and size preflight.\n * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} input - Artifact-set request.\n * @returns {{artifacts: import(\"../semantic/types.js\").GeneratedSetArtifact[], target: string}} Complete candidate set.\n */\nexport function generateRustProject({filename, mapDirective, module, sourceMapFilename, sources}) {\n  validateNativeGraph(module, \"rust\")\n  validateBackendModule(module, \"rust\")\n  validateRustValues(module)\n  if (filename !== undefined && filename != \"src/main.rs\") unsupportedCapability(\"rust\", \"artifact filename other than src/main.rs\", module.location)\n  if (mapDirective !== undefined || sourceMapFilename !== undefined) unsupportedCapability(\"rust\", \"source-map filename or directive option\", module.location)\n  new RustEmitter(module).program(module)\n  const writer = new SourceWriter({filename: \"src/main.rs\", language: \"rust\", module, sources})\n\n  new RustEmitter(module, writer).program(module)\n  const mapping = finalizeMapping(writer.finish())\n  const root = mapping.nodes.find(node => node.path == \"\")\n\n  if (!root) throw new Error(\"Validated Rust module omitted root provenance.\")\n  const origin = root.origin\n  const relatedOrigins = origin.kind == \"source\" ? [{location: origin.location, nodeId: root.id, role: \"module\", sourceId: origin.sourceId}] :\n    (origin.kind == \"derived\" ? origin.origins : origin.relatedOrigins).map(item => ({...item, nodeId: item.nodeId ?? root.id, role: item.role ?? \"module\"}))\n\n  return {target: \"rust\", artifacts: [{\n    path: \"Cargo.toml\", role: \"manifest\", ownership: \"generated\", contentKind: \"text\", mediaType: \"text/plain\", content: rustManifest,\n    provenance: {kind: \"synthetic\", reason: \"Fixed dependency-free edition-2021 Cargo package, Rust 1.98.1 minimum and matching dev/release abort/overflow profiles.\", relatedOrigins}\n  }, {\n    path: \"Cargo.lock\", role: \"support\", ownership: \"generated\", contentKind: \"text\", mediaType: \"text/plain\", content: rustLockfile,\n    provenance: {kind: \"synthetic\", reason: \"Exact dependency-free format-4 lockfile generated and qualified with Cargo 1.98.1.\", relatedOrigins}\n  }, {\n    path: \"src/main.rs\", role: \"entry\", ownership: \"generated\", contentKind: \"text\", mediaType: \"text/x-rust\", content: mapping.generated.content,\n    provenance: {kind: \"text\", mapping, sourceMap: toSourceMapV3(mapping)}\n  }]}\n}\n\n/** Emits native left-to-right expressions with explicit owned String copy boundaries. */\nclass RustEmitter {\n  /**\n   * Binds validated result types and an optional writer for the size-only preflight.\n   * @param {SemanticModule} module - Complete validated semantics.\n   * @param {SourceWriter} [writer] - Absent during size preflight.\n   */\n  constructor(module, writer) {\n    this.writer = writer\n    /** @type {Map<string, Scalar>} */\n    this.functions = new Map(module.functions.map(declaration => [declaration.name, rustScalarType(declaration.returnType, declaration.location)]))\n    this.length = 0\n    this.location = module.location\n  }\n\n  /**\n   * Bounds exact source length before any public artifact or writer is exposed.\n   * @param {string} text - Next text chunk.\n   * @param {SemanticNode} node - Related semantic origin.\n   * @returns {void}\n   */\n  checkSize(text, node) {\n    this.length += text.length\n    if (this.length > maximumRustSourceLength) unsupportedCapability(\"rust\", \"generated program exceeds the frozen Rust parser's 32767 UTF-16 input limit\",\n      \"location\" in node ? node.location : this.location)\n  }\n\n  /**\n   * Emits target-owned syntax with explicit related semantic provenance.\n   * @param {string} text - Rust syntax.\n   * @param {SemanticNode} node - Related node.\n   * @param {string} path - Semantic occurrence.\n   * @param {string} [reason] - Synthetic syntax purpose.\n   * @returns {void}\n   */\n  synthetic(text, node, path, reason = \"Rust declaration and expression syntax\") {\n    this.checkSize(text, node)\n    this.writer?.synthetic(text, reason, [node], [path])\n  }\n\n  /**\n   * Emits an original semantic token or declaration anchor.\n   * @param {string} text - Target token.\n   * @param {SemanticNode} node - Original node.\n   * @param {string} path - Occurrence path.\n   * @param {string} [role] - Original parser role.\n   * @returns {void}\n   */\n  mapped(text, node, path, role) {\n    this.checkSize(text, node)\n    this.writer?.mapped(text, {mappingKind: role ? \"exact\" : \"anchor\", node, path, ...(role ? {role} : {})})\n  }\n\n  /**\n   * Resolves an already validated expression's native scalar representation.\n   * @param {Expression} expression - Validated expression.\n   * @param {Map<string, Scalar>} bindings - Lexical types.\n   * @returns {Scalar} Result scalar.\n   */\n  type(expression, bindings) {\n    if (expression.kind == \"IntegerLiteral\") return \"integer\"\n    if (expression.kind == \"BooleanLiteral\") return \"boolean\"\n    if (expression.kind == \"StringLiteral\") return \"string\"\n    if (expression.kind == \"UnaryExpression\" || expression.kind == \"BinaryExpression\") return expression.type\n    if (expression.kind != \"CallExpression\" && expression.kind != \"IdentifierExpression\") {\n      return unsupportedCapability(\"rust\", \"collection expression reached scalar emission\", expression.location)\n    }\n    const type = expression.kind == \"CallExpression\" ? this.functions.get(expression.callee) : bindings.get(expression.name)\n\n    if (!type) throw new Error(\"Validated Rust expression lost its scalar type.\")\n    return type\n  }\n\n  /**\n   * Emits fixed support, crate-root functions and the parameterless entry point.\n   * @param {SemanticModule} module - Validated module.\n   * @returns {void}\n   */\n  program(module) {\n    this.synthetic(rustRuntime, module, \"\", \"Exact Rust scalar, print and overflow support\")\n    module.functions.forEach((declaration, index) => {\n      const path = `/functions/${index}`\n\n      this.synthetic(\"\\n\", declaration, path)\n      this.mapped(\"fn\", declaration, path)\n      this.synthetic(\" \", declaration, path)\n      this.mapped(declaration.name, declaration, path, \"name\")\n      this.synthetic(\"(\", declaration, path)\n      declaration.parameters.forEach((parameter, parameterIndex) => {\n        const parameterPath = `${path}/parameters/${parameterIndex}`\n\n        if (parameterIndex) this.synthetic(\", \", parameter, parameterPath)\n        this.mapped(parameter.name, parameter, parameterPath, \"name\")\n        this.synthetic(\": \", parameter, parameterPath)\n        this.mapped(emitScalarType(\"rust\", parameter.type), parameter.type, `${parameterPath}/type`, \"type\")\n      })\n      this.synthetic(\") -> \", declaration, path)\n      this.mapped(emitScalarType(\"rust\", declaration.returnType), declaration.returnType, `${path}/returnType`, \"type\")\n      this.synthetic(\" {\\n\", declaration, path)\n      this.block(declaration.body, `${path}/body`, \"    \", new Map(declaration.parameters.map(parameter => [\n        parameter.name, rustScalarType(parameter.type, parameter.location)\n      ])))\n      this.synthetic(\"}\\n\", declaration, path)\n    })\n    this.synthetic(\"\\nfn main() {\\n\", module.entryPoint, \"/entryPoint\")\n    this.block(module.entryPoint.body, \"/entryPoint/body\", \"    \", new Map())\n    this.synthetic(\"}\\n\", module.entryPoint, \"/entryPoint\")\n  }\n\n  /**\n   * Emits statements in order with independent branch binding environments.\n   * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n   * @param {string} path - Occurrence path.\n   * @param {string} indent - Current indentation.\n   * @param {Map<string, Scalar>} inherited - Visible lexical types.\n   * @param {number} [depth] - Exact generated CST block depth, root source file at zero.\n   * @returns {void}\n   */\n  block(block, path, indent, inherited, depth = 2) {\n    if (depth + 1 > 512) unsupportedCapability(\"rust\", \"generated Rust CST exceeds the 512-level traversal limit\", block.location)\n    const bindings = new Map(inherited)\n\n    block.statements.forEach((statement, index) => {\n      this.statement(statement, `${path}/statements/${index}`, indent, bindings, depth)\n      if (statement.kind == \"LocalDeclaration\") bindings.set(statement.name, rustScalarType(statement.type, statement.location))\n    })\n  }\n\n  /**\n   * Emits one semantic statement, copying String values except for terminal owned returns.\n   * @param {import(\"../semantic/types.js\").Statement} statement - Statement.\n   * @param {string} path - Occurrence path.\n   * @param {string} indent - Indentation.\n   * @param {Map<string, Scalar>} bindings - Visible types.\n   * @param {number} depth - Enclosing generated CST block depth.\n   * @returns {void}\n   */\n  statement(statement, path, indent, bindings, depth) {\n    this.synthetic(indent, statement, path)\n    if (statement.kind == \"ExpressionStatement\") throw new TypeError(\"Rust Task 005 expression statement reached emission.\")\n    if (statement.kind == \"LocalDeclaration\") {\n      this.mapped(statement.mutable ? \"let mut\" : \"let\", statement, path)\n      this.synthetic(\" \", statement, path)\n      this.mapped(statement.name, statement, path, \"name\")\n      this.synthetic(\": \", statement, path)\n      this.mapped(emitScalarType(\"rust\", statement.type), statement.type, `${path}/type`, \"type\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(\"=\", statement, path, \"operator\")\n      this.synthetic(\" \", statement, path)\n      this.expression(statement.initializer, `${path}/initializer`, bindings, true, depth + 2)\n    } else if (statement.kind == \"AssignmentStatement\") {\n      this.mapped(statement.target.name, statement.target, `${path}/target`, \"name\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(\"=\", statement, path, \"operator\")\n      this.synthetic(\" \", statement, path)\n      this.expression(statement.expression, `${path}/expression`, bindings, true, depth + 3)\n    } else if (statement.kind == \"ReturnStatement\") {\n      if (!statement.expression) throw new TypeError(\"Rust bare return reached emission.\")\n      this.mapped(\"return\", statement, path)\n      this.synthetic(\" \", statement, path)\n      this.expression(statement.expression, `${path}/expression`, bindings, false, depth + 3)\n    } else if (statement.kind == \"PrintStatement\") {\n      this.mapped(`semantifold_print_${this.type(statement.expression, bindings)}`, statement, path)\n      this.synthetic(\"(\", statement, path)\n      this.expression(statement.expression, `${path}/expression`, bindings, true, depth + 4)\n      this.synthetic(\")\", statement, path)\n    } else if (statement.kind == \"IfStatement\") {\n      this.mapped(\"if\", statement, path)\n      this.synthetic(\" \", statement, path)\n      this.expression(statement.condition, `${path}/condition`, bindings, true, depth + 3)\n      this.synthetic(\" {\\n\", statement, path)\n      this.block(statement.consequent, `${path}/consequent`, indent + \"    \", bindings, depth + 3)\n      this.synthetic(indent + \"}\", statement, path)\n      if (statement.alternate) {\n        this.mapped(\" else \", statement, path)\n        this.synthetic(\"{\\n\", statement, path)\n        this.block(statement.alternate, `${path}/alternate`, indent + \"    \", bindings, depth + 4)\n        this.synthetic(indent + \"}\", statement, path)\n      }\n      this.synthetic(\"\\n\", statement, path)\n      return\n    } else {\n      throw new TypeError(\"Unsupported Rust statement reached emission.\")\n    }\n    this.synthetic(\";\\n\", statement, path)\n  }\n\n  /**\n   * Emits ordinary Rust left-to-right and short-circuit expressions without temporary reordering.\n   * @param {Expression} expression - Expression occurrence.\n   * @param {string} path - Occurrence path.\n   * @param {Map<string, Scalar>} bindings - Lexical types.\n   * @param {boolean} [copy] - Whether an identifier crosses an owned value-copy boundary.\n   * @param {number} [depth] - Exact generated CST expression depth.\n   * @returns {void}\n   */\n  expression(expression, path, bindings, copy = true, depth = 0) {\n    const leafDepth = expression.kind == \"StringLiteral\" ? 3 : expression.kind == \"IdentifierExpression\" && copy && this.type(expression, bindings) == \"string\" ? 2 :\n      expression.kind == \"BooleanLiteral\" ? 1 : 0\n\n    if (depth + leafDepth > 512) unsupportedCapability(\"rust\", \"generated Rust CST exceeds the 512-level traversal limit\", expression.location)\n    if (expression.kind == \"IdentifierExpression\") {\n      this.mapped(expression.name, expression, path, \"name\")\n      if (copy && this.type(expression, bindings) == \"string\") this.synthetic(\".clone()\", expression, path, \"Owned String value copy\")\n    } else if (expression.kind == \"BooleanLiteral\") this.mapped(String(expression.value), expression, path, \"literal\")\n    else if (expression.kind == \"IntegerLiteral\") {\n      this.mapped(String(expression.value), expression, path, \"literal\")\n      this.synthetic(\"i64\", expression, path, \"Exact signed-64-bit scalar suffix\")\n    } else if (expression.kind == \"StringLiteral\") {\n      this.synthetic(\"String::from(\", expression, path, \"Owned UTF-8 String construction\")\n      let literal = '\"'\n\n      for (const character of expression.value) {\n        const codePoint = /** @type {number} */ (character.codePointAt(0))\n\n        if (character == '\"') literal += '\\\\\"'\n        else if (character == \"\\\\\") literal += \"\\\\\\\\\"\n        else if (codePoint < 32 || codePoint == 127 || codePoint == 0x2028 || codePoint == 0x2029) literal += `\\\\u{${codePoint.toString(16)}}`\n        else literal += character\n      }\n      this.mapped(literal + '\"', expression, path, \"literal\")\n      this.synthetic(\")\", expression, path, \"Owned UTF-8 String construction\")\n    } else if (expression.kind == \"CallExpression\") {\n      this.mapped(expression.callee, expression, path, \"callee\")\n      this.synthetic(\"(\", expression, path)\n      expression.arguments.forEach((argument, index) => {\n        if (index) this.synthetic(\", \", expression, path)\n        this.expression(argument, `${path}/arguments/${index}`, bindings, true, depth + 2)\n      })\n      this.synthetic(\")\", expression, path)\n    } else if (expression.kind == \"UnaryExpression\") {\n      this.mapped(expression.operation == \"IntegerNegate\" ? \"semantifold_integer_negate\" : \"!\", expression, path, \"operator\")\n      this.synthetic(\"(\", expression, path)\n      this.expression(expression.operand, `${path}/operand`, bindings, true, depth + 2)\n      this.synthetic(\")\", expression, path)\n    } else {\n      if (expression.kind != \"BinaryExpression\") {\n        return unsupportedCapability(\"rust\", \"collection expression reached scalar emission\", expression.location)\n      }\n      const token = operators.get(expression.operation)\n\n      if (!token) throw new Error(\"Unsupported operation passed Rust validation.\")\n      const helper = token.startsWith(\"semantifold_\")\n      const comparison = expression.operation == \"StringEqual\" || expression.operation == \"StringNotEqual\"\n\n      if (helper) this.mapped(token, expression, path, \"operator\")\n      this.synthetic(\"(\", expression, path)\n      this.expression(expression.left, `${path}/left`, bindings, !comparison, depth + 2)\n      if (helper) this.synthetic(\", \", expression, path)\n      else {\n        this.synthetic(\" \", expression, path)\n        this.mapped(token, expression, path, \"operator\")\n        this.synthetic(\" \", expression, path)\n      }\n      if (expression.operation == \"StringConcat\") this.synthetic(\"&(\", expression.right, `${path}/right`, \"Borrowed String concatenation operand\")\n      this.expression(expression.right, `${path}/right`, bindings, !comparison && expression.operation != \"StringConcat\",\n        depth + (expression.operation == \"StringConcat\" ? 4 : 2))\n      if (expression.operation == \"StringConcat\") this.synthetic(\")\", expression.right, `${path}/right`, \"Borrowed String concatenation operand\")\n      this.synthetic(\")\", expression, path)\n    }\n  }\n}\n\n/**\n * Narrows a type after Rust collection capability rejection.\n * @param {import(\"../semantic/types.js\").SemanticFunctionReturnType} type - Semantic type.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Owning location.\n * @returns {Scalar} Scalar type.\n */\nfunction rustScalarType(type, location) {\n  if (type.kind != \"TypeReference\" || type.name == \"void\") {\n    return unsupportedCapability(\"rust\", \"collection or void type reached scalar emission\", location)\n  }\n\n  return type.name\n}\n"]}