semantifold 0.3.0 → 0.4.0

package/build/src/frontends/rust.js

@@ -0,0 +1,715 @@
+// @ts-check
+import { rustRuntime } from "../backends/rust-runtime.js";
+import { maximumRustSourceLength } from "../backends/rust-validation.js";
+import { isRustIdentifier } from "../backends/identifiers.js";
+import { missingType, SemantifoldDiagnostic, unsupportedSyntax } from "../diagnostic.js";
+import { createCoordinateIndex, indexedPointAt } from "../semantic/location.js";
+import { withAdaptedOperation } from "../semantic/operators.js";
+import { withParserRanges } from "../semantic/provenance.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { validateParsedModule } from "../semantic/validate.js";
+import { sourceScalarType } from "./scalars.js";
+import { parseRustCst } from "./rust-parser.js";
+/** @typedef {import("./rust-parser.js").CstNode} CstNode */
+/** @typedef {import("../semantic/types.js").Expression} Expression */
+/** @typedef {import("../semantic/types.js").Statement} Statement */
+/** @typedef {import("../semantic/types.js").SemanticTypeName} Scalar */
+const binaryOperations = new Map([
+    ["+", "Add"], ["-", "Subtract"], ["*", "Multiply"], ["==", "Equal"], ["!=", "NotEqual"],
+    ["<", "LessThan"], ["<=", "LessThanOrEqual"], [">", "GreaterThan"], [">=", "GreaterThanOrEqual"],
+    ["&&", "And"], ["||", "Or"]
+]);
+const arithmeticHelpers = new Map([
+    ["semantifold_integer_add", "PhpAdd"], ["semantifold_integer_subtract", "Subtract"],
+    ["semantifold_integer_multiply", "Multiply"]
+]);
+/** Consumes complete Rust CST shapes and retains source-only scaffold constraints. */
+class RustReader {
+    /**
+     * Owns source text and parser-origin metadata, never native parser handles.
+     * @param {string} filename - Original filename.
+     * @param {string} source - Exact source.
+     */
+    constructor(filename, source) {
+        this.filename = filename;
+        this.source = source;
+        this.coordinates = createCoordinateIndex(source);
+        /** @type {Set<string>} */
+        this.helpers = new Set();
+        /** @type {Map<Expression, CstNode>} */
+        this.clones = new Map();
+        /** @type {Map<Expression, {borrowed: boolean, node: CstNode}>} */
+        this.additions = new Map();
+        /** @type {Map<Statement, {type: string, node: CstNode}>} */
+        this.prints = new Map();
+        /** @type {Map<string, Scalar>} */
+        this.functions = new Map();
+    }
+    /**
+     * Locates an original parser node in UTF-16 coordinates.
+     * @param {CstNode} node - Original node.
+     * @returns {import("../semantic/types.js").SourceLocation} Exact location.
+     */
+    location(node) {
+        return { filename: this.filename, start: indexedPointAt(this.coordinates, node.startIndex), end: indexedPointAt(this.coordinates, node.endIndex) };
+    }
+    /**
+     * Reads the spelling of an already recognized parser node.
+     * @param {CstNode} node - Recognized node.
+     * @returns {string} Original spelling.
+     */
+    text(node) {
+        return this.source.slice(node.startIndex, node.endIndex);
+    }
+    /**
+     * Rejects one located source-profile violation.
+     * @param {CstNode} node - Violating node.
+     * @param {string} [detail] - Profile detail.
+     * @returns {never} Always throws.
+     */
+    fail(node, detail = node.type) {
+        unsupportedSyntax("rust", detail, this.location(node));
+    }
+    /**
+     * Accounts for recovery, every extra, and doc comments before interpreting meaning.
+     * @param {CstNode} node - Current node.
+     * @param {number} [depth] - Bounded traversal depth.
+     * @returns {void}
+     */
+    validateTree(node, depth = 0) {
+        if (depth > 512)
+            this.fail(node, "Rust CST exceeds the 512-level traversal limit");
+        for (const { node: child } of node.children)
+            this.validateTree(child, depth + 1);
+        if (node.error || node.missing || node.hasError) {
+            throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "rust", location: this.location(node), message: `Rust parser recovery at '${node.type}'.` });
+        }
+        if (node.extra && !["line_comment", "block_comment"].includes(node.type))
+            this.fail(node, "unexpected extra parser child");
+        if (["line_comment", "block_comment"].includes(node.type) && /^(?:\/\/[!/]|\/\*[*!])/u.test(this.text(node))) {
+            this.fail(node, "doc-comment attribute");
+        }
+    }
+    /**
+     * Omits only inert comments already checked during exhaustive traversal.
+     * @param {CstNode} node - Parent.
+     * @returns {CstNode[]} Ordered structural children.
+     */
+    parts(node) {
+        return node.children.map(({ node: child }) => child).filter(child => !["line_comment", "block_comment"].includes(child.type));
+    }
+    /**
+     * Requires an exact sole parser field.
+     * @param {CstNode} node - Field owner.
+     * @param {string} name - Field name.
+     * @returns {CstNode} Sole field value.
+     */
+    field(node, name) {
+        const edges = node.children.filter(({ field }) => field == name);
+        if (edges.length != 1)
+            this.fail(node, `expected one '${name}' field`);
+        return edges[0].node;
+    }
+    /**
+     * Requires all ordered children, including anonymous punctuation.
+     * @param {CstNode} node - Shape owner.
+     * @param {(CstNode | string)[]} expected - Exact child sequence.
+     * @returns {void}
+     */
+    shape(node, expected) {
+        const parts = this.parts(node);
+        if (parts.length != expected.length || parts.some((child, index) => typeof expected[index] == "string" ? child.type != expected[index] || !child.named && this.text(child) != expected[index] : child !== expected[index]))
+            this.fail(node, `${node.type} child shape`);
+    }
+    /**
+     * Protects Rust keywords and the private support namespace.
+     * @param {CstNode} node - Identifier token.
+     * @returns {string} Validated name.
+     */
+    identifier(node) {
+        const name = this.text(node);
+        if (node.type != "identifier" || !isRustIdentifier(name))
+            this.fail(node, "reserved or unsupported identifier");
+        return name;
+    }
+    /**
+     * Accepts only explicitly spelled i64, bool and owned String.
+     * @param {CstNode} node - Type token.
+     * @returns {import("../semantic/types.js").TypeReference} Semantic scalar type.
+     */
+    type(node) {
+        if (node.children.length || !["primitive_type", "type_identifier"].includes(node.type))
+            this.fail(node, "scalar type shape");
+        const spelling = this.text(node);
+        const type = sourceScalarType("rust", spelling, this.location(node));
+        if (!type)
+            return missingType("rust", "scalar", this.location(node));
+        if ((spelling == "String") != (node.type == "type_identifier"))
+            this.fail(node, "scalar type spelling");
+        return type;
+    }
+    /**
+     * Converts exact call syntax without interpreting macro token trees as calls.
+     * @param {CstNode} node - Call expression.
+     * @returns {{name: CstNode, arguments: CstNode[]}} Parsed direct argument sequence.
+     */
+    call(node) {
+        if (node.type != "call_expression")
+            this.fail(node, "direct call required");
+        const name = this.field(node, "function");
+        const list = this.field(node, "arguments");
+        this.shape(node, [name, list]);
+        if (list.type != "arguments")
+            this.fail(list, "call arguments");
+        const args = this.parts(list).slice(1, -1).filter((_part, index) => index % 2 == 0);
+        this.shape(list, ["(", ...args.flatMap((arg, index) => index == 0 ? [arg] : [",", arg]), ")"]);
+        return { arguments: args, name };
+    }
+    /**
+     * Decodes parser-owned ordinary string content and exact scalar escapes.
+     * @param {CstNode} node - String literal.
+     * @returns {string} Unicode scalar value.
+     */
+    string(node) {
+        if (node.type != "string_literal")
+            this.fail(node, "ordinary String literal required");
+        const parts = this.parts(node);
+        this.shape(node, ['"', ...parts.slice(1, -1), '"']);
+        let value = "";
+        for (const part of parts.slice(1, -1)) {
+            const spelling = this.text(part);
+            if (part.type == "string_content") {
+                if (/[\r\n]/u.test(spelling))
+                    this.fail(part, "raw string line terminator");
+                value += spelling;
+            }
+            else if (part.type == "escape_sequence") {
+                const escape = spelling.slice(1);
+                const simple = new Map([["0", "\0"], ["n", "\n"], ["r", "\r"], ["t", "\t"], ["\\", "\\"], ['"', '"'], ["'", "'"]]);
+                if (spelling[0] != "\\")
+                    this.fail(part, "escape prefix");
+                if (simple.has(escape))
+                    value += simple.get(escape);
+                else if (/^x[0-9a-fA-F]{2}$/u.test(escape)) {
+                    const scalar = Number.parseInt(escape.slice(1), 16);
+                    if (scalar > 127)
+                        this.fail(part, "non-ASCII byte escape");
+                    value += String.fromCodePoint(scalar);
+                }
+                else if (/^u\{[0-9a-fA-F]{1,6}\}$/u.test(escape)) {
+                    const scalar = Number.parseInt(escape.slice(2, -1), 16);
+                    if (scalar > 0x10FFFF || scalar >= 0xD800 && scalar <= 0xDFFF)
+                        this.fail(part, "non-scalar Unicode escape");
+                    value += String.fromCodePoint(scalar);
+                }
+                else
+                    this.fail(part, "unsupported string escape");
+            }
+            else
+                this.fail(part, "string child");
+        }
+        return value;
+    }
+    /**
+     * Converts exact scalar expressions while retaining source clone/borrow constraints.
+     * @param {CstNode} node - Expression node.
+     * @returns {Expression} Pending typed semantic expression.
+     */
+    expression(node) {
+        const location = this.location(node);
+        if (node.type == "parenthesized_expression") {
+            const parts = this.parts(node);
+            this.shape(node, ["(", parts[1], ")"]);
+            return this.expression(parts[1]);
+        }
+        if (node.type == "identifier")
+            return withParserRanges({ kind: "IdentifierExpression", location, name: this.identifier(node) }, { name: location });
+        if (node.type == "integer_literal") {
+            const spelling = this.text(node);
+            const value = Number(spelling.slice(0, -3));
+            if (!/^(?:0|[1-9][0-9]*)i64$/u.test(spelling) || !Number.isSafeInteger(value))
+                this.fail(node, "non-safe or noncanonical i64 literal");
+            return withParserRanges({ kind: "IntegerLiteral", location, value }, { literal: location });
+        }
+        if (node.type == "boolean_literal") {
+            const spelling = this.text(node);
+            if (spelling != "true" && spelling != "false")
+                this.fail(node, "Boolean literal spelling");
+            this.shape(node, [spelling]);
+            return withParserRanges({ kind: "BooleanLiteral", location, value: spelling == "true" }, { literal: location });
+        }
+        if (node.type == "unary_expression") {
+            const parts = this.parts(node);
+            this.shape(node, [parts[0], parts[1]]);
+            if (!["-", "!"].includes(parts[0].type))
+                this.fail(parts[0], "unary operator");
+            return this.unary(node, parts[0].type == "-" ? "Negate" : "Not", this.expression(parts[1]), parts[0]);
+        }
+        if (node.type == "binary_expression") {
+            const left = this.field(node, "left");
+            const right = this.field(node, "right");
+            const operator = this.field(node, "operator");
+            const intent = binaryOperations.get(operator.type);
+            this.shape(node, [left, operator, right]);
+            if (!intent)
+                this.fail(operator, "unsupported binary operator");
+            const borrowed = operator.type == "+" && right.type == "reference_expression";
+            const value = borrowed ? this.field(right, "value") : right;
+            if (borrowed)
+                this.shape(right, ["&", value]);
+            const expression = this.binary(node, intent, this.expression(left), this.expression(value), operator);
+            if (operator.type == "+")
+                this.additions.set(expression, { borrowed, node: right });
+            return expression;
+        }
+        if (node.type == "call_expression") {
+            const call = this.call(node);
+            const name = this.text(call.name);
+            if (call.name.type == "scoped_identifier") {
+                const owner = this.field(call.name, "path");
+                const method = this.field(call.name, "name");
+                this.shape(call.name, [owner, "::", method]);
+                if (owner.type != "identifier" || this.text(owner) != "String" || method.type != "identifier" || this.text(method) != "from" || call.arguments.length != 1) {
+                    this.fail(call.name, "exact String::from construction required");
+                }
+                return withParserRanges({ kind: "StringLiteral", location, value: this.string(call.arguments[0]) }, { literal: this.location(call.arguments[0]) });
+            }
+            if (call.name.type == "field_expression") {
+                const receiver = this.field(call.name, "value");
+                const method = this.field(call.name, "field");
+                this.shape(call.name, [receiver, ".", method]);
+                if (method.type != "field_identifier" || this.text(method) != "clone" || call.arguments.length)
+                    this.fail(call.name, "exact owned String clone required");
+                const expression = this.expression(receiver);
+                this.clones.set(expression, call.name);
+                return expression;
+            }
+            if (call.name.type != "identifier")
+                this.fail(call.name, "direct function call required");
+            if (this.helpers.has(name) && name == "semantifold_integer_negate") {
+                if (call.arguments.length != 1)
+                    this.fail(node, "negation helper arity");
+                return this.unary(node, "Negate", this.expression(call.arguments[0]), call.name);
+            }
+            const intent = this.helpers.has(name) ? arithmeticHelpers.get(name) : undefined;
+            if (intent) {
+                if (call.arguments.length != 2)
+                    this.fail(node, "arithmetic helper arity");
+                return this.binary(node, intent, this.expression(call.arguments[0]), this.expression(call.arguments[1]), call.name);
+            }
+            const callee = this.identifier(call.name);
+            if (call.arguments.length != 2)
+                this.fail(node, "semantic call arity");
+            return withParserRanges({ kind: "CallExpression", location, callee, arguments: call.arguments.map(argument => this.expression(argument)) }, { callee: this.location(call.name) });
+        }
+        return this.fail(node);
+    }
+    /**
+     * Retains parser operator intent until shared scalar resolution.
+     * @param {CstNode} node - Owning node.
+     * @param {string} intent - Parser operation.
+     * @param {Expression} left - Left operand.
+     * @param {Expression} right - Right operand.
+     * @param {CstNode} operator - Exact operator token.
+     * @returns {Expression} Pending binary expression.
+     */
+    binary(node, intent, left, right, operator) {
+        return /** @type {Expression} */ (withAdaptedOperation(withParserRanges({ kind: "BinaryExpression", location: this.location(node), left, right }, { operator: this.location(operator) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (intent)));
+    }
+    /**
+     * Retains unary parser intent and its original token range.
+     * @param {CstNode} node - Owning node.
+     * @param {"Negate" | "Not"} intent - Unary intent.
+     * @param {Expression} operand - Operand.
+     * @param {CstNode} operator - Exact token.
+     * @returns {Expression} Pending unary expression.
+     */
+    unary(node, intent, operand, operator) {
+        return /** @type {Expression} */ (withAdaptedOperation(withParserRanges({ kind: "UnaryExpression", location: this.location(node), operand }, { operator: this.location(operator) }), intent));
+    }
+    /**
+     * Converts one explicitly typed initialized binding or executable statement.
+     * @param {CstNode} node - Statement.
+     * @returns {Statement} Semantic statement.
+     */
+    statement(node) {
+        const location = this.location(node);
+        const parts = this.parts(node);
+        if (node.type == "let_declaration") {
+            const typeNode = node.children.find(({ field }) => field == "type")?.node;
+            if (!typeNode)
+                return missingType("rust", "local", location);
+            const name = this.field(node, "pattern");
+            const value = this.field(node, "value");
+            const mutable = parts[1].type == "mutable_specifier";
+            this.shape(node, ["let", ...(mutable ? [parts[1]] : []), name, ":", typeNode, "=", value, ";"]);
+            if (mutable && this.text(parts[1]) != "mut")
+                this.fail(parts[1], "mutability token");
+            return withParserRanges({ kind: "LocalDeclaration", location, name: this.identifier(name), type: this.type(typeNode), mutable,
+                initializer: this.expression(value) }, { name: this.location(name), operator: this.location(parts[parts.length - 3]) });
+        }
+        if (node.type != "expression_statement")
+            this.fail(node, "explicit statement required; tail expressions are unsupported");
+        const expression = parts[0];
+        if (expression.type == "if_expression") {
+            this.shape(node, [expression]);
+            return this.conditional(expression);
+        }
+        this.shape(node, [expression, ";"]);
+        if (expression.type == "return_expression") {
+            const returned = this.parts(expression);
+            this.shape(expression, ["return", returned[1]]);
+            return { kind: "ReturnStatement", location, expression: this.expression(returned[1]) };
+        }
+        if (expression.type == "assignment_expression") {
+            const left = this.field(expression, "left");
+            const right = this.field(expression, "right");
+            this.shape(expression, [left, "=", right]);
+            const target = withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: this.location(left), name: this.identifier(left) }, { name: this.location(left) });
+            return withParserRanges({ kind: "AssignmentStatement", location, target, expression: this.expression(right) }, { operator: this.location(this.parts(expression)[1]) });
+        }
+        const call = this.call(expression);
+        const name = this.text(call.name);
+        if (call.name.type != "identifier" || !this.helpers.has(name) || !/^semantifold_print_(?:integer|boolean|string)$/u.test(name) || call.arguments.length != 1)
+            this.fail(node, "exact print helper call required");
+        const statement = { kind: /** @type {const} */ ("PrintStatement"), location, expression: this.expression(call.arguments[0]) };
+        this.prints.set(statement, { node: call.name, type: name.slice("semantifold_print_".length) });
+        return statement;
+    }
+    /**
+     * Converts exact braced conditionals and else-if nesting.
+     * @param {CstNode} node - If expression used as a statement.
+     * @returns {import("../semantic/types.js").IfStatement} Conditional statement.
+     */
+    conditional(node) {
+        const condition = this.field(node, "condition");
+        const consequence = this.field(node, "consequence");
+        const alternative = node.children.find(({ field }) => field == "alternative")?.node;
+        this.shape(node, ["if", condition, consequence, ...(alternative ? [alternative] : [])]);
+        const statement = { kind: /** @type {const} */ ("IfStatement"), location: this.location(node), condition: this.expression(condition), consequent: this.block(consequence) };
+        if (!alternative)
+            return statement;
+        const branch = this.parts(alternative)[1];
+        this.shape(alternative, ["else", branch]);
+        return { ...statement, alternate: branch.type == "if_expression" ? { kind: "Block", location: this.location(branch), statements: [this.conditional(branch)] } : this.block(branch) };
+    }
+    /**
+     * Converts one complete lexical block.
+     * @param {CstNode} node - Braced block.
+     * @returns {import("../semantic/types.js").Block} Semantic block.
+     */
+    block(node) {
+        if (node.type != "block")
+            this.fail(node, "braced block required");
+        const parts = this.parts(node);
+        this.shape(node, ["{", ...parts.slice(1, -1), "}"]);
+        return { kind: "Block", location: this.location(node), statements: parts.slice(1, -1).map(child => this.statement(child)) };
+    }
+    /**
+     * Converts a crate-root function with exactly two required by-value parameters.
+     * @param {CstNode} node - Function item.
+     * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic declaration.
+     */
+    function(node) {
+        const name = this.field(node, "name");
+        const parameters = this.field(node, "parameters");
+        const returnType = node.children.find(({ field }) => field == "return_type")?.node;
+        const body = this.field(node, "body");
+        if (!returnType)
+            return missingType("rust", "function return", this.location(node));
+        this.shape(node, ["fn", name, parameters, "->", returnType, body]);
+        this.shape(parameters, ["(", "parameter", ",", "parameter", ")"]);
+        const converted = [this.parts(parameters)[1], this.parts(parameters)[3]].map(parameter => {
+            const pattern = this.field(parameter, "pattern");
+            const type = this.field(parameter, "type");
+            this.shape(parameter, [pattern, ":", type]);
+            return withParserRanges({ kind: /** @type {const} */ ("Parameter"), location: this.location(parameter), name: this.identifier(pattern), type: this.type(type) }, { name: this.location(pattern) });
+        });
+        return withParserRanges({ kind: "FunctionDeclaration", location: this.location(node), name: this.identifier(name), parameters: converted,
+            returnType: this.type(returnType), body: this.block(body) }, { name: this.location(name) });
+    }
+    /**
+     * Compares all fields, children and leaf spellings against qualified support syntax.
+     * @param {CstNode} actual - Original node.
+     * @param {CstNode} expected - Qualified node.
+     * @param {RustReader} canonical - Qualified spelling reader.
+     * @returns {void}
+     */
+    compareTree(actual, expected, canonical) {
+        if (actual.type != expected.type || actual.named != expected.named || actual.extra != expected.extra)
+            this.fail(actual, "modified Rust support node");
+        const left = this.parts(actual);
+        const right = canonical.parts(expected);
+        if (left.length != right.length)
+            this.fail(actual, "modified Rust support children");
+        if (!left.length && this.text(actual) != canonical.text(expected))
+            this.fail(actual, "modified Rust support token");
+        left.forEach((child, index) => {
+            if (actual.children.find(edge => edge.node === child)?.field != expected.children.find(edge => edge.node === right[index])?.field)
+                this.fail(child, "modified Rust support field");
+            this.compareTree(child, right[index], canonical);
+        });
+    }
+    /**
+     * Resolves only already validated scalar expressions for scaffold checking.
+     * @param {Expression} expression - Resolved semantic expression.
+     * @param {Map<string, Scalar>} bindings - Lexical types.
+     * @returns {Scalar} Semantic result type.
+     */
+    expressionType(expression, bindings) {
+        if (expression.kind == "StringLiteral")
+            return "string";
+        if (expression.kind == "IntegerLiteral")
+            return "integer";
+        if (expression.kind == "BooleanLiteral")
+            return "boolean";
+        if (expression.kind == "BinaryExpression" || expression.kind == "UnaryExpression")
+            return expression.type;
+        if (expression.kind != "CallExpression" && expression.kind != "IdentifierExpression") {
+            throw new Error("Validated Rust source exposed a collection expression.");
+        }
+        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 binding.");
+        return type;
+    }
+    /**
+     * Checks clone, borrow and print constraints after shared operation resolution.
+     * @param {import("../semantic/types.js").Block} block - Resolved block.
+     * @param {Map<string, Scalar>} inherited - Enclosing types.
+     * @returns {void}
+     */
+    validateScalars(block, inherited) {
+        const bindings = new Map(inherited);
+        /**
+         * Checks each original clone and borrowed concatenation after scalar resolution.
+         * @param {Expression} expression - Current expression.
+         * @returns {void}
+         */
+        const visit = expression => {
+            const clone = this.clones.get(expression);
+            const addition = this.additions.get(expression);
+            if (clone && this.expressionType(expression, bindings) != "string")
+                this.fail(clone, "clone requires owned String");
+            if (addition && (this.expressionType(expression, bindings) == "string") != addition.borrowed)
+                this.fail(addition.node, "string concatenation requires exactly a borrowed String RHS");
+            if (expression.kind == "CallExpression")
+                expression.arguments.forEach(visit);
+            else if (expression.kind == "UnaryExpression")
+                visit(expression.operand);
+            else if (expression.kind == "BinaryExpression") {
+                visit(expression.left);
+                visit(expression.right);
+            }
+        };
+        for (const statement of block.statements) {
+            const expression = statement.kind == "IfStatement" ? statement.condition :
+                statement.kind == "LocalDeclaration" ? statement.initializer :
+                    statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" ? statement.expression :
+                        statement.kind == "ReturnStatement" ? statement.expression : undefined;
+            if (!expression)
+                throw new Error("Validated Rust source contained a bare return.");
+            visit(expression);
+            if (statement.kind == "LocalDeclaration")
+                bindings.set(statement.name, 
+                /** @type {import("../semantic/types.js").TypeReference} */ (statement.type).name);
+            if (statement.kind == "PrintStatement") {
+                const print = this.prints.get(statement);
+                if (!print)
+                    throw new Error("Rust print lost its original helper identity.");
+                if (this.expressionType(expression, bindings) != print.type)
+                    this.fail(print.node, "print helper scalar mismatch");
+            }
+            if (statement.kind == "IfStatement") {
+                this.validateScalars(statement.consequent, bindings);
+                if (statement.alternate)
+                    this.validateScalars(statement.alternate, bindings);
+            }
+        }
+    }
+    /**
+     * Validates genuine source moves in evaluation order, retaining implicit comparison borrows.
+     * @param {Expression} expression - Original expression occurrence.
+     * @param {Map<string, Scalar>} bindings - Validated lexical types.
+     * @param {Set<string>} moved - Definitely or possibly consumed String bindings.
+     * @param {Set<string>} borrowed - Borrows held by enclosing operand evaluation.
+     * @param {"move" | "borrow"} [usage] - How this expression's result is consumed.
+     * @param {boolean} [applyClone] - Whether to apply this occurrence's checked clone wrapper.
+     * @returns {Set<string>} Place borrows held until the containing operation completes.
+     */
+    ownershipExpression(expression, bindings, moved, borrowed, usage = "move", applyClone = true) {
+        if (applyClone && this.clones.has(expression)) {
+            this.ownershipExpression(expression, bindings, moved, borrowed, "borrow", false);
+            return new Set();
+        }
+        if (expression.kind == "IdentifierExpression" && this.expressionType(expression, bindings) == "string") {
+            const name = expression.name;
+            if (moved.has(name))
+                unsupportedSyntax("rust", `use of moved String '${name}'`, expression.location);
+            if (usage == "borrow")
+                return new Set([name]);
+            if (borrowed.has(name))
+                unsupportedSyntax("rust", `cannot move borrowed String '${name}' during operand evaluation`, expression.location);
+            moved.add(name);
+        }
+        else if (expression.kind == "CallExpression") {
+            for (const argument of expression.arguments)
+                this.ownershipExpression(argument, bindings, moved, borrowed);
+        }
+        else if (expression.kind == "UnaryExpression")
+            this.ownershipExpression(expression.operand, bindings, moved, borrowed);
+        else if (expression.kind == "BinaryExpression") {
+            if (expression.operation == "StringEqual" || expression.operation == "StringNotEqual") {
+                const held = this.ownershipExpression(expression.left, bindings, moved, borrowed, "borrow");
+                this.ownershipExpression(expression.right, bindings, moved, new Set([...borrowed, ...held]), "borrow");
+            }
+            else {
+                this.ownershipExpression(expression.left, bindings, moved, borrowed);
+                if (expression.operation == "BooleanAnd" || expression.operation == "BooleanOr") {
+                    const conditional = new Set(moved);
+                    this.ownershipExpression(expression.right, bindings, conditional, borrowed);
+                    for (const name of conditional)
+                        moved.add(name);
+                }
+                else
+                    this.ownershipExpression(expression.right, bindings, moved, borrowed, expression.operation == "StringConcat" ? "borrow" : "move");
+            }
+        }
+        return new Set();
+    }
+    /**
+     * Merges source availability only from paths that continue, restoring explicit assignments.
+     * @param {import("../semantic/types.js").Block} block - Original lexical block.
+     * @param {Map<string, Scalar>} inherited - Visible scalar bindings.
+     * @param {Set<string>} inheritedMoved - Incoming consumed bindings.
+     * @returns {{moved: Set<string>, returns: boolean}} Outgoing source availability and control flow.
+     */
+    validateOwnership(block, inherited, inheritedMoved) {
+        const bindings = new Map(inherited);
+        const moved = new Set(inheritedMoved);
+        for (const statement of block.statements) {
+            const expression = statement.kind == "IfStatement" ? statement.condition :
+                statement.kind == "LocalDeclaration" ? statement.initializer :
+                    statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" ? statement.expression :
+                        statement.kind == "ReturnStatement" ? statement.expression : undefined;
+            if (!expression)
+                throw new Error("Validated Rust source contained a bare return.");
+            this.ownershipExpression(expression, bindings, moved, new Set());
+            if (statement.kind == "ReturnStatement")
+                return { moved, returns: true };
+            if (statement.kind == "LocalDeclaration")
+                bindings.set(statement.name, 
+                /** @type {import("../semantic/types.js").TypeReference} */ (statement.type).name);
+            else if (statement.kind == "AssignmentStatement")
+                moved.delete(statement.target.name);
+            else if (statement.kind == "IfStatement") {
+                const consequent = this.validateOwnership(statement.consequent, bindings, moved);
+                const alternate = statement.alternate ? this.validateOwnership(statement.alternate, bindings, moved) : { moved: new Set(moved), returns: false };
+                if (consequent.returns && alternate.returns)
+                    return { moved, returns: true };
+                moved.clear();
+                for (const path of [consequent, alternate]) {
+                    if (!path.returns)
+                        for (const name of path.moved)
+                            if (bindings.has(name))
+                                moved.add(name);
+                }
+            }
+        }
+        return { moved, returns: false };
+    }
+    /**
+     * Validates the complete crate and collapses only exact declared support.
+     * @param {CstNode} root - Complete root.
+     * @returns {import("../semantic/types.js").SemanticModule} Resolved semantics.
+     */
+    module(root) {
+        this.validateTree(root);
+        if (root.type != "source_file")
+            this.fail(root, "crate root required");
+        const canonical = new RustReader(this.filename, rustRuntime);
+        const support = canonical.parts(parseRustCst(rustRuntime).root);
+        const helpers = new Map(support.filter(node => node.type == "function_item").map(node => [canonical.text(canonical.field(node, "name")), node]));
+        /** @type {CstNode[]} */
+        const definitions = [];
+        let lint = false;
+        /** @type {CstNode | undefined} */
+        let main;
+        for (const node of this.parts(root)) {
+            if (node.type == "inner_attribute_item") {
+                if (lint || definitions.length || main || this.helpers.size)
+                    this.fail(node, "misplaced Rust lint support");
+                this.compareTree(node, support[0], canonical);
+                lint = true;
+                continue;
+            }
+            if (node.type != "function_item")
+                this.fail(node, "crate-root free functions only");
+            const name = this.text(this.field(node, "name"));
+            const helper = helpers.get(name);
+            if (helper) {
+                if (this.helpers.has(name))
+                    this.fail(node, "duplicate Rust helper");
+                this.compareTree(node, helper, canonical);
+                this.helpers.add(name);
+            }
+            else if (name == "main") {
+                if (main)
+                    this.fail(node, "duplicate main");
+                main = node;
+            }
+            else
+                definitions.push(node);
+        }
+        if (!main)
+            this.fail(root, "canonical fn main() required");
+        if (!definitions.length)
+            this.fail(root, "semantic function required");
+        const name = this.field(main, "name");
+        const parameters = this.field(main, "parameters");
+        const body = this.field(main, "body");
+        this.shape(main, ["fn", name, parameters, body]);
+        this.shape(parameters, ["(", ")"]);
+        const module = validateParsedModule({ kind: "Module", location: this.location(root), functions: definitions.map(node => this.function(node)),
+            entryPoint: { kind: "EntryPoint", location: this.location(main), body: this.block(body) } }, "rust");
+        this.functions = new Map(module.functions.map(declaration => [
+            declaration.name,
+            /** @type {Scalar} */ ( /** @type {import("../semantic/types.js").TypeReference} */(declaration.returnType).name)
+        ]));
+        for (const declaration of module.functions) {
+            const bindings = new Map(declaration.parameters.map(parameter => [parameter.name,
+                /** @type {import("../semantic/types.js").TypeReference} */ (parameter.type).name]));
+            this.validateScalars(declaration.body, bindings);
+            this.validateOwnership(declaration.body, bindings, new Set());
+        }
+        this.validateScalars(module.entryPoint.body, new Map());
+        this.validateOwnership(module.entryPoint.body, new Map(), new Set());
+        return module;
+    }
+}
+/**
+ * Parses only the qualified frozen CST and rejects unsupported input before adaptation.
+ * @param {{filename: string, source: string}} input - Exact source request.
+ * @returns {import("../semantic/types.js").SemanticModule} Rust semantic module.
+ */
+export function parseRust({ filename, source }) {
+    const coordinates = createCoordinateIndex(source);
+    const location = { filename, start: indexedPointAt(coordinates, 0), end: indexedPointAt(coordinates, source.length) };
+    if (!hasOnlyUnicodeScalars(source)) {
+        const offset = source.search(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u);
+        throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "rust", message: "Rust source contains a lone UTF-16 surrogate.",
+            location: { filename, start: indexedPointAt(coordinates, offset), end: indexedPointAt(coordinates, offset + 1) } });
+    }
+    if (source.length > maximumRustSourceLength)
+        return unsupportedSyntax("rust", "source exceeds the frozen Rust parser's 32767 UTF-16 input limit", location);
+    let snapshot;
+    try {
+        snapshot = parseRustCst(source);
+    }
+    catch (error) {
+        throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "rust", location,
+            cause: error instanceof Error ? error : undefined, message: "The qualified Rust parser could not produce a complete CST." });
+    }
+    return new RustReader(filename, source).module(snapshot.root);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust.js","sourceRoot":"","sources":["../../../src/frontends/rust.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {rustRuntime} from \"../backends/rust-runtime.js\"\nimport {maximumRustSourceLength} from \"../backends/rust-validation.js\"\nimport {isRustIdentifier} from \"../backends/identifiers.js\"\nimport {missingType, SemantifoldDiagnostic, unsupportedSyntax} from \"../diagnostic.js\"\nimport {createCoordinateIndex, indexedPointAt} from \"../semantic/location.js\"\nimport {withAdaptedOperation} from \"../semantic/operators.js\"\nimport {withParserRanges} from \"../semantic/provenance.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {validateParsedModule} from \"../semantic/validate.js\"\nimport {sourceScalarType} from \"./scalars.js\"\nimport {parseRustCst} from \"./rust-parser.js\"\n\n/** @typedef {import(\"./rust-parser.js\").CstNode} CstNode */\n/** @typedef {import(\"../semantic/types.js\").Expression} Expression */\n/** @typedef {import(\"../semantic/types.js\").Statement} Statement */\n/** @typedef {import(\"../semantic/types.js\").SemanticTypeName} Scalar */\n\nconst binaryOperations = new Map([\n  [\"+\", \"Add\"], [\"-\", \"Subtract\"], [\"*\", \"Multiply\"], [\"==\", \"Equal\"], [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"], [\"<=\", \"LessThanOrEqual\"], [\">\", \"GreaterThan\"], [\">=\", \"GreaterThanOrEqual\"],\n  [\"&&\", \"And\"], [\"||\", \"Or\"]\n])\nconst arithmeticHelpers = new Map([\n  [\"semantifold_integer_add\", \"PhpAdd\"], [\"semantifold_integer_subtract\", \"Subtract\"],\n  [\"semantifold_integer_multiply\", \"Multiply\"]\n])\n\n/** Consumes complete Rust CST shapes and retains source-only scaffold constraints. */\nclass RustReader {\n  /**\n   * Owns source text and parser-origin metadata, never native parser handles.\n   * @param {string} filename - Original filename.\n   * @param {string} source - Exact source.\n   */\n  constructor(filename, source) {\n    this.filename = filename\n    this.source = source\n    this.coordinates = createCoordinateIndex(source)\n    /** @type {Set<string>} */\n    this.helpers = new Set()\n    /** @type {Map<Expression, CstNode>} */\n    this.clones = new Map()\n    /** @type {Map<Expression, {borrowed: boolean, node: CstNode}>} */\n    this.additions = new Map()\n    /** @type {Map<Statement, {type: string, node: CstNode}>} */\n    this.prints = new Map()\n    /** @type {Map<string, Scalar>} */\n    this.functions = new Map()\n  }\n\n  /**\n   * Locates an original parser node in UTF-16 coordinates.\n   * @param {CstNode} node - Original node.\n   * @returns {import(\"../semantic/types.js\").SourceLocation} Exact location.\n   */\n  location(node) {\n    return {filename: this.filename, start: indexedPointAt(this.coordinates, node.startIndex), end: indexedPointAt(this.coordinates, node.endIndex)}\n  }\n\n  /**\n   * Reads the spelling of an already recognized parser node.\n   * @param {CstNode} node - Recognized node.\n   * @returns {string} Original spelling.\n   */\n  text(node) {\n    return this.source.slice(node.startIndex, node.endIndex)\n  }\n\n  /**\n   * Rejects one located source-profile violation.\n   * @param {CstNode} node - Violating node.\n   * @param {string} [detail] - Profile detail.\n   * @returns {never} Always throws.\n   */\n  fail(node, detail = node.type) {\n    unsupportedSyntax(\"rust\", detail, this.location(node))\n  }\n\n  /**\n   * Accounts for recovery, every extra, and doc comments before interpreting meaning.\n   * @param {CstNode} node - Current node.\n   * @param {number} [depth] - Bounded traversal depth.\n   * @returns {void}\n   */\n  validateTree(node, depth = 0) {\n    if (depth > 512) this.fail(node, \"Rust CST exceeds the 512-level traversal limit\")\n    for (const {node: child} of node.children) this.validateTree(child, depth + 1)\n    if (node.error || node.missing || node.hasError) {\n      throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"rust\", location: this.location(node), message: `Rust parser recovery at '${node.type}'.`})\n    }\n    if (node.extra && ![\"line_comment\", \"block_comment\"].includes(node.type)) this.fail(node, \"unexpected extra parser child\")\n    if ([\"line_comment\", \"block_comment\"].includes(node.type) && /^(?:\\/\\/[!/]|\\/\\*[*!])/u.test(this.text(node))) {\n      this.fail(node, \"doc-comment attribute\")\n    }\n  }\n\n  /**\n   * Omits only inert comments already checked during exhaustive traversal.\n   * @param {CstNode} node - Parent.\n   * @returns {CstNode[]} Ordered structural children.\n   */\n  parts(node) {\n    return node.children.map(({node: child}) => child).filter(child => ![\"line_comment\", \"block_comment\"].includes(child.type))\n  }\n\n  /**\n   * Requires an exact sole parser field.\n   * @param {CstNode} node - Field owner.\n   * @param {string} name - Field name.\n   * @returns {CstNode} Sole field value.\n   */\n  field(node, name) {\n    const edges = node.children.filter(({field}) => field == name)\n\n    if (edges.length != 1) this.fail(node, `expected one '${name}' field`)\n    return edges[0].node\n  }\n\n  /**\n   * Requires all ordered children, including anonymous punctuation.\n   * @param {CstNode} node - Shape owner.\n   * @param {(CstNode | string)[]} expected - Exact child sequence.\n   * @returns {void}\n   */\n  shape(node, expected) {\n    const parts = this.parts(node)\n\n    if (parts.length != expected.length || parts.some((child, index) =>\n      typeof expected[index] == \"string\" ? child.type != expected[index] || !child.named && this.text(child) != expected[index] : child !== expected[index])) this.fail(node, `${node.type} child shape`)\n  }\n\n  /**\n   * Protects Rust keywords and the private support namespace.\n   * @param {CstNode} node - Identifier token.\n   * @returns {string} Validated name.\n   */\n  identifier(node) {\n    const name = this.text(node)\n\n    if (node.type != \"identifier\" || !isRustIdentifier(name)) this.fail(node, \"reserved or unsupported identifier\")\n    return name\n  }\n\n  /**\n   * Accepts only explicitly spelled i64, bool and owned String.\n   * @param {CstNode} node - Type token.\n   * @returns {import(\"../semantic/types.js\").TypeReference} Semantic scalar type.\n   */\n  type(node) {\n    if (node.children.length || ![\"primitive_type\", \"type_identifier\"].includes(node.type)) this.fail(node, \"scalar type shape\")\n    const spelling = this.text(node)\n    const type = sourceScalarType(\"rust\", spelling, this.location(node))\n\n    if (!type) return missingType(\"rust\", \"scalar\", this.location(node))\n    if ((spelling == \"String\") != (node.type == \"type_identifier\")) this.fail(node, \"scalar type spelling\")\n    return type\n  }\n\n  /**\n   * Converts exact call syntax without interpreting macro token trees as calls.\n   * @param {CstNode} node - Call expression.\n   * @returns {{name: CstNode, arguments: CstNode[]}} Parsed direct argument sequence.\n   */\n  call(node) {\n    if (node.type != \"call_expression\") this.fail(node, \"direct call required\")\n    const name = this.field(node, \"function\")\n    const list = this.field(node, \"arguments\")\n\n    this.shape(node, [name, list])\n    if (list.type != \"arguments\") this.fail(list, \"call arguments\")\n    const args = this.parts(list).slice(1, -1).filter((_part, index) => index % 2 == 0)\n\n    this.shape(list, [\"(\", ...args.flatMap((arg, index) => index == 0 ? [arg] : [\",\", arg]), \")\"])\n    return {arguments: args, name}\n  }\n\n  /**\n   * Decodes parser-owned ordinary string content and exact scalar escapes.\n   * @param {CstNode} node - String literal.\n   * @returns {string} Unicode scalar value.\n   */\n  string(node) {\n    if (node.type != \"string_literal\") this.fail(node, \"ordinary String literal required\")\n    const parts = this.parts(node)\n\n    this.shape(node, ['\"', ...parts.slice(1, -1), '\"'])\n    let value = \"\"\n\n    for (const part of parts.slice(1, -1)) {\n      const spelling = this.text(part)\n\n      if (part.type == \"string_content\") {\n        if (/[\\r\\n]/u.test(spelling)) this.fail(part, \"raw string line terminator\")\n        value += spelling\n      } else if (part.type == \"escape_sequence\") {\n        const escape = spelling.slice(1)\n        const simple = new Map([[\"0\", \"\\0\"], [\"n\", \"\\n\"], [\"r\", \"\\r\"], [\"t\", \"\\t\"], [\"\\\\\", \"\\\\\"], ['\"', '\"'], [\"'\", \"'\"]])\n\n        if (spelling[0] != \"\\\\\") this.fail(part, \"escape prefix\")\n        if (simple.has(escape)) value += simple.get(escape)\n        else if (/^x[0-9a-fA-F]{2}$/u.test(escape)) {\n          const scalar = Number.parseInt(escape.slice(1), 16)\n\n          if (scalar > 127) this.fail(part, \"non-ASCII byte escape\")\n          value += String.fromCodePoint(scalar)\n        } else if (/^u\\{[0-9a-fA-F]{1,6}\\}$/u.test(escape)) {\n          const scalar = Number.parseInt(escape.slice(2, -1), 16)\n\n          if (scalar > 0x10FFFF || scalar >= 0xD800 && scalar <= 0xDFFF) this.fail(part, \"non-scalar Unicode escape\")\n          value += String.fromCodePoint(scalar)\n        } else this.fail(part, \"unsupported string escape\")\n      } else this.fail(part, \"string child\")\n    }\n    return value\n  }\n\n  /**\n   * Converts exact scalar expressions while retaining source clone/borrow constraints.\n   * @param {CstNode} node - Expression node.\n   * @returns {Expression} Pending typed semantic expression.\n   */\n  expression(node) {\n    const location = this.location(node)\n\n    if (node.type == \"parenthesized_expression\") {\n      const parts = this.parts(node)\n\n      this.shape(node, [\"(\", parts[1], \")\"])\n      return this.expression(parts[1])\n    }\n    if (node.type == \"identifier\") return withParserRanges({kind: \"IdentifierExpression\", location, name: this.identifier(node)}, {name: location})\n    if (node.type == \"integer_literal\") {\n      const spelling = this.text(node)\n      const value = Number(spelling.slice(0, -3))\n\n      if (!/^(?:0|[1-9][0-9]*)i64$/u.test(spelling) || !Number.isSafeInteger(value)) this.fail(node, \"non-safe or noncanonical i64 literal\")\n      return withParserRanges({kind: \"IntegerLiteral\", location, value}, {literal: location})\n    }\n    if (node.type == \"boolean_literal\") {\n      const spelling = this.text(node)\n\n      if (spelling != \"true\" && spelling != \"false\") this.fail(node, \"Boolean literal spelling\")\n      this.shape(node, [spelling])\n      return withParserRanges({kind: \"BooleanLiteral\", location, value: spelling == \"true\"}, {literal: location})\n    }\n    if (node.type == \"unary_expression\") {\n      const parts = this.parts(node)\n\n      this.shape(node, [parts[0], parts[1]])\n      if (![\"-\", \"!\"].includes(parts[0].type)) this.fail(parts[0], \"unary operator\")\n      return this.unary(node, parts[0].type == \"-\" ? \"Negate\" : \"Not\", this.expression(parts[1]), parts[0])\n    }\n    if (node.type == \"binary_expression\") {\n      const left = this.field(node, \"left\")\n      const right = this.field(node, \"right\")\n      const operator = this.field(node, \"operator\")\n      const intent = binaryOperations.get(operator.type)\n\n      this.shape(node, [left, operator, right])\n      if (!intent) this.fail(operator, \"unsupported binary operator\")\n      const borrowed = operator.type == \"+\" && right.type == \"reference_expression\"\n      const value = borrowed ? this.field(right, \"value\") : right\n\n      if (borrowed) this.shape(right, [\"&\", value])\n      const expression = this.binary(node, intent, this.expression(left), this.expression(value), operator)\n\n      if (operator.type == \"+\") this.additions.set(expression, {borrowed, node: right})\n      return expression\n    }\n    if (node.type == \"call_expression\") {\n      const call = this.call(node)\n      const name = this.text(call.name)\n\n      if (call.name.type == \"scoped_identifier\") {\n        const owner = this.field(call.name, \"path\")\n        const method = this.field(call.name, \"name\")\n\n        this.shape(call.name, [owner, \"::\", method])\n        if (owner.type != \"identifier\" || this.text(owner) != \"String\" || method.type != \"identifier\" || this.text(method) != \"from\" || call.arguments.length != 1) {\n          this.fail(call.name, \"exact String::from construction required\")\n        }\n        return withParserRanges({kind: \"StringLiteral\", location, value: this.string(call.arguments[0])}, {literal: this.location(call.arguments[0])})\n      }\n      if (call.name.type == \"field_expression\") {\n        const receiver = this.field(call.name, \"value\")\n        const method = this.field(call.name, \"field\")\n\n        this.shape(call.name, [receiver, \".\", method])\n        if (method.type != \"field_identifier\" || this.text(method) != \"clone\" || call.arguments.length) this.fail(call.name, \"exact owned String clone required\")\n        const expression = this.expression(receiver)\n\n        this.clones.set(expression, call.name)\n        return expression\n      }\n      if (call.name.type != \"identifier\") this.fail(call.name, \"direct function call required\")\n      if (this.helpers.has(name) && name == \"semantifold_integer_negate\") {\n        if (call.arguments.length != 1) this.fail(node, \"negation helper arity\")\n        return this.unary(node, \"Negate\", this.expression(call.arguments[0]), call.name)\n      }\n      const intent = this.helpers.has(name) ? arithmeticHelpers.get(name) : undefined\n\n      if (intent) {\n        if (call.arguments.length != 2) this.fail(node, \"arithmetic helper arity\")\n        return this.binary(node, intent, this.expression(call.arguments[0]), this.expression(call.arguments[1]), call.name)\n      }\n      const callee = this.identifier(call.name)\n\n      if (call.arguments.length != 2) this.fail(node, \"semantic call arity\")\n      return withParserRanges({kind: \"CallExpression\", location, callee, arguments: call.arguments.map(argument => this.expression(argument))}, {callee: this.location(call.name)})\n    }\n    return this.fail(node)\n  }\n\n  /**\n   * Retains parser operator intent until shared scalar resolution.\n   * @param {CstNode} node - Owning node.\n   * @param {string} intent - Parser operation.\n   * @param {Expression} left - Left operand.\n   * @param {Expression} right - Right operand.\n   * @param {CstNode} operator - Exact operator token.\n   * @returns {Expression} Pending binary expression.\n   */\n  binary(node, intent, left, right, operator) {\n    return /** @type {Expression} */ (withAdaptedOperation(withParserRanges({kind: \"BinaryExpression\", location: this.location(node), left, right},\n      {operator: this.location(operator)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (intent)))\n  }\n\n  /**\n   * Retains unary parser intent and its original token range.\n   * @param {CstNode} node - Owning node.\n   * @param {\"Negate\" | \"Not\"} intent - Unary intent.\n   * @param {Expression} operand - Operand.\n   * @param {CstNode} operator - Exact token.\n   * @returns {Expression} Pending unary expression.\n   */\n  unary(node, intent, operand, operator) {\n    return /** @type {Expression} */ (withAdaptedOperation(withParserRanges({kind: \"UnaryExpression\", location: this.location(node), operand},\n      {operator: this.location(operator)}), intent))\n  }\n\n  /**\n   * Converts one explicitly typed initialized binding or executable statement.\n   * @param {CstNode} node - Statement.\n   * @returns {Statement} Semantic statement.\n   */\n  statement(node) {\n    const location = this.location(node)\n    const parts = this.parts(node)\n\n    if (node.type == \"let_declaration\") {\n      const typeNode = node.children.find(({field}) => field == \"type\")?.node\n\n      if (!typeNode) return missingType(\"rust\", \"local\", location)\n      const name = this.field(node, \"pattern\")\n      const value = this.field(node, \"value\")\n      const mutable = parts[1].type == \"mutable_specifier\"\n\n      this.shape(node, [\"let\", ...(mutable ? [parts[1]] : []), name, \":\", typeNode, \"=\", value, \";\"])\n      if (mutable && this.text(parts[1]) != \"mut\") this.fail(parts[1], \"mutability token\")\n      return withParserRanges({kind: \"LocalDeclaration\", location, name: this.identifier(name), type: this.type(typeNode), mutable,\n        initializer: this.expression(value)}, {name: this.location(name), operator: this.location(parts[parts.length - 3])})\n    }\n    if (node.type != \"expression_statement\") this.fail(node, \"explicit statement required; tail expressions are unsupported\")\n    const expression = parts[0]\n\n    if (expression.type == \"if_expression\") {\n      this.shape(node, [expression])\n      return this.conditional(expression)\n    }\n    this.shape(node, [expression, \";\"])\n    if (expression.type == \"return_expression\") {\n      const returned = this.parts(expression)\n\n      this.shape(expression, [\"return\", returned[1]])\n      return {kind: \"ReturnStatement\", location, expression: this.expression(returned[1])}\n    }\n    if (expression.type == \"assignment_expression\") {\n      const left = this.field(expression, \"left\")\n      const right = this.field(expression, \"right\")\n\n      this.shape(expression, [left, \"=\", right])\n      const target = withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: this.location(left), name: this.identifier(left)}, {name: this.location(left)})\n\n      return withParserRanges({kind: \"AssignmentStatement\", location, target, expression: this.expression(right)}, {operator: this.location(this.parts(expression)[1])})\n    }\n    const call = this.call(expression)\n    const name = this.text(call.name)\n\n    if (call.name.type != \"identifier\" || !this.helpers.has(name) || !/^semantifold_print_(?:integer|boolean|string)$/u.test(name) || call.arguments.length != 1) this.fail(node, \"exact print helper call required\")\n    const statement = {kind: /** @type {const} */ (\"PrintStatement\"), location, expression: this.expression(call.arguments[0])}\n\n    this.prints.set(statement, {node: call.name, type: name.slice(\"semantifold_print_\".length)})\n    return statement\n  }\n\n  /**\n   * Converts exact braced conditionals and else-if nesting.\n   * @param {CstNode} node - If expression used as a statement.\n   * @returns {import(\"../semantic/types.js\").IfStatement} Conditional statement.\n   */\n  conditional(node) {\n    const condition = this.field(node, \"condition\")\n    const consequence = this.field(node, \"consequence\")\n    const alternative = node.children.find(({field}) => field == \"alternative\")?.node\n\n    this.shape(node, [\"if\", condition, consequence, ...(alternative ? [alternative] : [])])\n    const statement = {kind: /** @type {const} */ (\"IfStatement\"), location: this.location(node), condition: this.expression(condition), consequent: this.block(consequence)}\n\n    if (!alternative) return statement\n    const branch = this.parts(alternative)[1]\n\n    this.shape(alternative, [\"else\", branch])\n    return {...statement, alternate: branch.type == \"if_expression\" ? {kind: \"Block\", location: this.location(branch), statements: [this.conditional(branch)]} : this.block(branch)}\n  }\n\n  /**\n   * Converts one complete lexical block.\n   * @param {CstNode} node - Braced block.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n   */\n  block(node) {\n    if (node.type != \"block\") this.fail(node, \"braced block required\")\n    const parts = this.parts(node)\n\n    this.shape(node, [\"{\", ...parts.slice(1, -1), \"}\"])\n    return {kind: \"Block\", location: this.location(node), statements: parts.slice(1, -1).map(child => this.statement(child))}\n  }\n\n  /**\n   * Converts a crate-root function with exactly two required by-value parameters.\n   * @param {CstNode} node - Function item.\n   * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic declaration.\n   */\n  function(node) {\n    const name = this.field(node, \"name\")\n    const parameters = this.field(node, \"parameters\")\n    const returnType = node.children.find(({field}) => field == \"return_type\")?.node\n    const body = this.field(node, \"body\")\n\n    if (!returnType) return missingType(\"rust\", \"function return\", this.location(node))\n    this.shape(node, [\"fn\", name, parameters, \"->\", returnType, body])\n    this.shape(parameters, [\"(\", \"parameter\", \",\", \"parameter\", \")\"])\n    const converted = [this.parts(parameters)[1], this.parts(parameters)[3]].map(parameter => {\n      const pattern = this.field(parameter, \"pattern\")\n      const type = this.field(parameter, \"type\")\n\n      this.shape(parameter, [pattern, \":\", type])\n      return withParserRanges({kind: /** @type {const} */ (\"Parameter\"), location: this.location(parameter), name: this.identifier(pattern), type: this.type(type)}, {name: this.location(pattern)})\n    })\n\n    return withParserRanges({kind: \"FunctionDeclaration\", location: this.location(node), name: this.identifier(name), parameters: converted,\n      returnType: this.type(returnType), body: this.block(body)}, {name: this.location(name)})\n  }\n\n  /**\n   * Compares all fields, children and leaf spellings against qualified support syntax.\n   * @param {CstNode} actual - Original node.\n   * @param {CstNode} expected - Qualified node.\n   * @param {RustReader} canonical - Qualified spelling reader.\n   * @returns {void}\n   */\n  compareTree(actual, expected, canonical) {\n    if (actual.type != expected.type || actual.named != expected.named || actual.extra != expected.extra) this.fail(actual, \"modified Rust support node\")\n    const left = this.parts(actual)\n    const right = canonical.parts(expected)\n\n    if (left.length != right.length) this.fail(actual, \"modified Rust support children\")\n    if (!left.length && this.text(actual) != canonical.text(expected)) this.fail(actual, \"modified Rust support token\")\n    left.forEach((child, index) => {\n      if (actual.children.find(edge => edge.node === child)?.field != expected.children.find(edge => edge.node === right[index])?.field) this.fail(child, \"modified Rust support field\")\n      this.compareTree(child, right[index], canonical)\n    })\n  }\n\n  /**\n   * Resolves only already validated scalar expressions for scaffold checking.\n   * @param {Expression} expression - Resolved semantic expression.\n   * @param {Map<string, Scalar>} bindings - Lexical types.\n   * @returns {Scalar} Semantic result type.\n   */\n  expressionType(expression, bindings) {\n    if (expression.kind == \"StringLiteral\") return \"string\"\n    if (expression.kind == \"IntegerLiteral\") return \"integer\"\n    if (expression.kind == \"BooleanLiteral\") return \"boolean\"\n    if (expression.kind == \"BinaryExpression\" || expression.kind == \"UnaryExpression\") return expression.type\n    if (expression.kind != \"CallExpression\" && expression.kind != \"IdentifierExpression\") {\n      throw new Error(\"Validated Rust source exposed a collection expression.\")\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 binding.\")\n    return type\n  }\n\n  /**\n   * Checks clone, borrow and print constraints after shared operation resolution.\n   * @param {import(\"../semantic/types.js\").Block} block - Resolved block.\n   * @param {Map<string, Scalar>} inherited - Enclosing types.\n   * @returns {void}\n   */\n  validateScalars(block, inherited) {\n    const bindings = new Map(inherited)\n    /**\n     * Checks each original clone and borrowed concatenation after scalar resolution.\n     * @param {Expression} expression - Current expression.\n     * @returns {void}\n     */\n    const visit = expression => {\n      const clone = this.clones.get(expression)\n      const addition = this.additions.get(expression)\n\n      if (clone && this.expressionType(expression, bindings) != \"string\") this.fail(clone, \"clone requires owned String\")\n      if (addition && (this.expressionType(expression, bindings) == \"string\") != addition.borrowed) this.fail(addition.node, \"string concatenation requires exactly a borrowed String RHS\")\n      if (expression.kind == \"CallExpression\") expression.arguments.forEach(visit)\n      else if (expression.kind == \"UnaryExpression\") visit(expression.operand)\n      else if (expression.kind == \"BinaryExpression\") { visit(expression.left); visit(expression.right) }\n    }\n\n    for (const statement of block.statements) {\n      const expression = statement.kind == \"IfStatement\" ? statement.condition :\n        statement.kind == \"LocalDeclaration\" ? statement.initializer :\n          statement.kind == \"AssignmentStatement\" || statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\" ? statement.expression :\n            statement.kind == \"ReturnStatement\" ? statement.expression : undefined\n\n      if (!expression) throw new Error(\"Validated Rust source contained a bare return.\")\n      visit(expression)\n      if (statement.kind == \"LocalDeclaration\") bindings.set(statement.name,\n        /** @type {import(\"../semantic/types.js\").TypeReference} */ (statement.type).name)\n      if (statement.kind == \"PrintStatement\") {\n        const print = this.prints.get(statement)\n\n        if (!print) throw new Error(\"Rust print lost its original helper identity.\")\n        if (this.expressionType(expression, bindings) != print.type) this.fail(print.node, \"print helper scalar mismatch\")\n      }\n      if (statement.kind == \"IfStatement\") {\n        this.validateScalars(statement.consequent, bindings)\n        if (statement.alternate) this.validateScalars(statement.alternate, bindings)\n      }\n    }\n  }\n\n  /**\n   * Validates genuine source moves in evaluation order, retaining implicit comparison borrows.\n   * @param {Expression} expression - Original expression occurrence.\n   * @param {Map<string, Scalar>} bindings - Validated lexical types.\n   * @param {Set<string>} moved - Definitely or possibly consumed String bindings.\n   * @param {Set<string>} borrowed - Borrows held by enclosing operand evaluation.\n   * @param {\"move\" | \"borrow\"} [usage] - How this expression's result is consumed.\n   * @param {boolean} [applyClone] - Whether to apply this occurrence's checked clone wrapper.\n   * @returns {Set<string>} Place borrows held until the containing operation completes.\n   */\n  ownershipExpression(expression, bindings, moved, borrowed, usage = \"move\", applyClone = true) {\n    if (applyClone && this.clones.has(expression)) {\n      this.ownershipExpression(expression, bindings, moved, borrowed, \"borrow\", false)\n      return new Set()\n    }\n    if (expression.kind == \"IdentifierExpression\" && this.expressionType(expression, bindings) == \"string\") {\n      const name = expression.name\n\n      if (moved.has(name)) unsupportedSyntax(\"rust\", `use of moved String '${name}'`, expression.location)\n      if (usage == \"borrow\") return new Set([name])\n      if (borrowed.has(name)) unsupportedSyntax(\"rust\", `cannot move borrowed String '${name}' during operand evaluation`, expression.location)\n      moved.add(name)\n    } else if (expression.kind == \"CallExpression\") {\n      for (const argument of expression.arguments) this.ownershipExpression(argument, bindings, moved, borrowed)\n    } else if (expression.kind == \"UnaryExpression\") this.ownershipExpression(expression.operand, bindings, moved, borrowed)\n    else if (expression.kind == \"BinaryExpression\") {\n      if (expression.operation == \"StringEqual\" || expression.operation == \"StringNotEqual\") {\n        const held = this.ownershipExpression(expression.left, bindings, moved, borrowed, \"borrow\")\n\n        this.ownershipExpression(expression.right, bindings, moved, new Set([...borrowed, ...held]), \"borrow\")\n      } else {\n        this.ownershipExpression(expression.left, bindings, moved, borrowed)\n        if (expression.operation == \"BooleanAnd\" || expression.operation == \"BooleanOr\") {\n          const conditional = new Set(moved)\n\n          this.ownershipExpression(expression.right, bindings, conditional, borrowed)\n          for (const name of conditional) moved.add(name)\n        } else this.ownershipExpression(expression.right, bindings, moved, borrowed, expression.operation == \"StringConcat\" ? \"borrow\" : \"move\")\n      }\n    }\n    return new Set()\n  }\n\n  /**\n   * Merges source availability only from paths that continue, restoring explicit assignments.\n   * @param {import(\"../semantic/types.js\").Block} block - Original lexical block.\n   * @param {Map<string, Scalar>} inherited - Visible scalar bindings.\n   * @param {Set<string>} inheritedMoved - Incoming consumed bindings.\n   * @returns {{moved: Set<string>, returns: boolean}} Outgoing source availability and control flow.\n   */\n  validateOwnership(block, inherited, inheritedMoved) {\n    const bindings = new Map(inherited)\n    const moved = new Set(inheritedMoved)\n\n    for (const statement of block.statements) {\n      const expression = statement.kind == \"IfStatement\" ? statement.condition :\n        statement.kind == \"LocalDeclaration\" ? statement.initializer :\n          statement.kind == \"AssignmentStatement\" || statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\" ? statement.expression :\n            statement.kind == \"ReturnStatement\" ? statement.expression : undefined\n\n      if (!expression) throw new Error(\"Validated Rust source contained a bare return.\")\n      this.ownershipExpression(expression, bindings, moved, new Set())\n      if (statement.kind == \"ReturnStatement\") return {moved, returns: true}\n      if (statement.kind == \"LocalDeclaration\") bindings.set(statement.name,\n        /** @type {import(\"../semantic/types.js\").TypeReference} */ (statement.type).name)\n      else if (statement.kind == \"AssignmentStatement\") moved.delete(statement.target.name)\n      else if (statement.kind == \"IfStatement\") {\n        const consequent = this.validateOwnership(statement.consequent, bindings, moved)\n        const alternate = statement.alternate ? this.validateOwnership(statement.alternate, bindings, moved) : {moved: new Set(moved), returns: false}\n\n        if (consequent.returns && alternate.returns) return {moved, returns: true}\n        moved.clear()\n        for (const path of [consequent, alternate]) {\n          if (!path.returns) for (const name of path.moved) if (bindings.has(name)) moved.add(name)\n        }\n      }\n    }\n    return {moved, returns: false}\n  }\n\n  /**\n   * Validates the complete crate and collapses only exact declared support.\n   * @param {CstNode} root - Complete root.\n   * @returns {import(\"../semantic/types.js\").SemanticModule} Resolved semantics.\n   */\n  module(root) {\n    this.validateTree(root)\n    if (root.type != \"source_file\") this.fail(root, \"crate root required\")\n    const canonical = new RustReader(this.filename, rustRuntime)\n    const support = canonical.parts(parseRustCst(rustRuntime).root)\n    const helpers = new Map(support.filter(node => node.type == \"function_item\").map(node => [canonical.text(canonical.field(node, \"name\")), node]))\n    /** @type {CstNode[]} */\n    const definitions = []\n    let lint = false\n    /** @type {CstNode | undefined} */\n    let main\n\n    for (const node of this.parts(root)) {\n      if (node.type == \"inner_attribute_item\") {\n        if (lint || definitions.length || main || this.helpers.size) this.fail(node, \"misplaced Rust lint support\")\n        this.compareTree(node, support[0], canonical)\n        lint = true\n        continue\n      }\n      if (node.type != \"function_item\") this.fail(node, \"crate-root free functions only\")\n      const name = this.text(this.field(node, \"name\"))\n      const helper = helpers.get(name)\n\n      if (helper) {\n        if (this.helpers.has(name)) this.fail(node, \"duplicate Rust helper\")\n        this.compareTree(node, helper, canonical)\n        this.helpers.add(name)\n      } else if (name == \"main\") {\n        if (main) this.fail(node, \"duplicate main\")\n        main = node\n      } else definitions.push(node)\n    }\n    if (!main) this.fail(root, \"canonical fn main() required\")\n    if (!definitions.length) this.fail(root, \"semantic function required\")\n    const name = this.field(main, \"name\")\n    const parameters = this.field(main, \"parameters\")\n    const body = this.field(main, \"body\")\n\n    this.shape(main, [\"fn\", name, parameters, body])\n    this.shape(parameters, [\"(\", \")\"])\n    const module = validateParsedModule({kind: \"Module\", location: this.location(root), functions: definitions.map(node => this.function(node)),\n      entryPoint: {kind: \"EntryPoint\", location: this.location(main), body: this.block(body)}}, \"rust\")\n\n    this.functions = new Map(module.functions.map(declaration => [\n      declaration.name,\n      /** @type {Scalar} */ (/** @type {import(\"../semantic/types.js\").TypeReference} */ (declaration.returnType).name)\n    ]))\n    for (const declaration of module.functions) {\n      const bindings = new Map(declaration.parameters.map(parameter => [parameter.name,\n        /** @type {import(\"../semantic/types.js\").TypeReference} */ (parameter.type).name]))\n\n      this.validateScalars(declaration.body, bindings)\n      this.validateOwnership(declaration.body, bindings, new Set())\n    }\n    this.validateScalars(module.entryPoint.body, new Map())\n    this.validateOwnership(module.entryPoint.body, new Map(), new Set())\n    return module\n  }\n}\n\n/**\n * Parses only the qualified frozen CST and rejects unsupported input before adaptation.\n * @param {{filename: string, source: string}} input - Exact source request.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Rust semantic module.\n */\nexport function parseRust({filename, source}) {\n  const coordinates = createCoordinateIndex(source)\n  const location = {filename, start: indexedPointAt(coordinates, 0), end: indexedPointAt(coordinates, source.length)}\n\n  if (!hasOnlyUnicodeScalars(source)) {\n    const offset = source.search(/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/u)\n\n    throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"rust\", message: \"Rust source contains a lone UTF-16 surrogate.\",\n      location: {filename, start: indexedPointAt(coordinates, offset), end: indexedPointAt(coordinates, offset + 1)}})\n  }\n  if (source.length > maximumRustSourceLength) return unsupportedSyntax(\"rust\", \"source exceeds the frozen Rust parser's 32767 UTF-16 input limit\", location)\n  let snapshot\n\n  try {\n    snapshot = parseRustCst(source)\n  } catch (error) {\n    throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"rust\", location,\n      cause: error instanceof Error ? error : undefined, message: \"The qualified Rust parser could not produce a complete CST.\"})\n  }\n  return new RustReader(filename, source).module(snapshot.root)\n}\n"]}