semantifold 0.3.0 → 0.5.0

package/build/src/frontends/swift.js

@@ -0,0 +1,860 @@
+// @ts-check
+import Parser from "tree-sitter";
+import SwiftLanguage from "tree-sitter-swift/bindings/node/index.js";
+import { isSwiftIdentifier } from "../backends/identifiers.js";
+import { swiftRuntime } from "../backends/swift-runtime.js";
+import { missingType, SemantifoldDiagnostic, unsupportedSyntax } from "../diagnostic.js";
+import { locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset } 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";
+const parser = new Parser();
+parser.setLanguage(/** @type {import("tree-sitter").Language} */ ( /** @type {unknown} */(SwiftLanguage)));
+const binaryOperations = new Map([
+    ["+", "Add"], ["-", "Subtract"], ["*", "Multiply"], ["==", "Equal"], ["!=", "NotEqual"],
+    ["<", "LessThan"], ["<=", "LessThanOrEqual"], [">", "GreaterThan"], [">=", "GreaterThanOrEqual"],
+    ["&&", "And"], ["||", "Or"]
+]);
+const binaryNodeOperators = new Map([
+    ["additive_expression", new Set(["+", "-"])],
+    ["multiplicative_expression", new Set(["*"])],
+    ["equality_expression", new Set(["=="])],
+    ["comparison_expression", new Set(["<", ">"])],
+    ["conjunction_expression", new Set(["&&"])],
+    ["disjunction_expression", new Set(["||"])],
+    ["infix_expression", new Set(["!=", "<=", ">="])]
+]);
+/** @type {Map<string, import("../semantic/operators.js").AdaptedOperation>} */
+const helperOperations = new Map([
+    ["semantifold_string_equal", "StringEqual"], ["semantifold_string_not_equal", "StringNotEqual"]
+]);
+/**
+ * Verifies a Tree-sitter binding index through the shared byte converter.
+ * @param {string} source - Complete source.
+ * @param {number} index - Binding-reported UTF-16 index.
+ * @returns {number} Verified UTF-16 offset.
+ */
+function bindingIndexToUtf16Offset(source, index) {
+    if (!Number.isInteger(index) || index < 0 || index > source.length ||
+        index > 0 && index < source.length && /[\uD800-\uDBFF]/u.test(source[index - 1]) && /[\uDC00-\uDFFF]/u.test(source[index])) {
+        throw new RangeError("Invalid Tree-sitter source index: " + index);
+    }
+    return utf8ByteOffsetToUtf16Offset(source, new TextEncoder().encode(source.slice(0, index)).length);
+}
+/**
+ * Finds an unpaired UTF-16 surrogate.
+ * @param {string} source - Complete source.
+ * @returns {number} Invalid offset or -1.
+ */
+function firstLoneSurrogateOffset(source) {
+    for (let index = 0; index < source.length; index += 1) {
+        const unit = source.charCodeAt(index);
+        if (unit >= 0xD800 && unit <= 0xDBFF) {
+            const next = source.charCodeAt(index + 1);
+            if (next >= 0xDC00 && next <= 0xDFFF)
+                index += 1;
+            else
+                return index;
+        }
+        else if (unit >= 0xDC00 && unit <= 0xDFFF)
+            return index;
+    }
+    return -1;
+}
+/** Consumes exact qualified Swift CST shapes without retaining parser handles. */
+class SwiftReader {
+    /**
+     * Creates a reader over one parser-owned Swift source.
+     * @param {string} filename - Original filename.
+     * @param {string} source - Complete source.
+     */
+    constructor(filename, source) {
+        this.filename = filename;
+        this.source = source;
+        /** @type {Set<string>} */
+        this.helpers = new Set();
+        this.mutableMarker = false;
+        /** @type {WeakMap<object, import("tree-sitter").SyntaxNode>} */
+        this.nativeEqualityOperators = new WeakMap();
+    }
+    /**
+     * Converts one parser range to Semantifold UTF-16 coordinates.
+     * @param {import("tree-sitter").SyntaxNode} node - Parser node.
+     * @returns {import("../semantic/types.js").SourceLocation} Exact location.
+     */
+    location(node) {
+        return locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, node.startIndex), bindingIndexToUtf16Offset(this.source, node.endIndex));
+    }
+    /**
+     * Rejects one located source-profile violation.
+     * @param {import("tree-sitter").SyntaxNode} node - Violating node.
+     * @param {string} [detail] - Profile detail.
+     * @returns {never} Always throws.
+     */
+    fail(node, detail = node.type) {
+        unsupportedSyntax("swift", detail, this.location(node));
+    }
+    /**
+     * Traverses every named, anonymous, extra, directive, and recovery node.
+     * @param {import("tree-sitter").SyntaxNode} root - Complete parser root.
+     * @returns {void}
+     */
+    validateTree(root) {
+        const pending = [{ depth: 0, node: root, visited: false }];
+        while (pending.length) {
+            const current = pending.pop();
+            if (!current)
+                throw new Error("Swift traversal lost a pending parser node.");
+            const { depth, node, visited } = current;
+            if (depth > 512)
+                this.fail(node, "CST exceeds the 512-level traversal limit");
+            if (!visited) {
+                pending.push({ depth, node, visited: true });
+                for (let index = node.childCount - 1; index >= 0; index -= 1) {
+                    const child = node.child(index);
+                    if (!child)
+                        throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`);
+                    pending.push({ depth: depth + 1, node: child, visited: false });
+                }
+                continue;
+            }
+            if (node.hasError || node.isError || node.isMissing) {
+                throw new SemantifoldDiagnostic({
+                    code: "PARSE_ERROR",
+                    language: "swift",
+                    location: this.location(node),
+                    message: `Tree-sitter exposed recovery at '${node.type}'.`
+                });
+            }
+            if (["attribute", "directive", "shebang_line"].includes(node.type))
+                this.fail(node, node.type);
+            if (node.type == "comment" && /swift-tools-version/u.test(node.text)) {
+                this.fail(node, "directive-bearing comment");
+            }
+        }
+    }
+    /**
+     * Omits only inert comments already accounted for by exhaustive traversal.
+     * @param {import("tree-sitter").SyntaxNode} node - Parent node.
+     * @returns {import("tree-sitter").SyntaxNode[]} Structural children.
+     */
+    parts(node) {
+        return node.children.filter((child) => child.type != "comment");
+    }
+    /**
+     * Requires one exact parser field edge.
+     * @param {import("tree-sitter").SyntaxNode} node - Field owner.
+     * @param {string} name - Field name.
+     * @returns {import("tree-sitter").SyntaxNode} Sole field node.
+     */
+    field(node, name) {
+        const matches = [];
+        for (let index = 0; index < node.childCount; index += 1) {
+            const child = node.child(index);
+            if (!child)
+                throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`);
+            if (node.fieldNameForChild(index) == name)
+                matches.push(child);
+        }
+        if (matches.length != 1)
+            this.fail(node, `expected one '${name}' field`);
+        return matches[0];
+    }
+    /**
+     * Requires all ordered children, including anonymous punctuation.
+     * @param {import("tree-sitter").SyntaxNode} node - Shape owner.
+     * @param {(import("tree-sitter").SyntaxNode | string)[]} expected - Exact child sequence.
+     * @returns {void}
+     */
+    shape(node, expected) {
+        const actual = this.parts(node);
+        if (actual.length != expected.length)
+            this.fail(actual[Math.min(actual.length, expected.length)] ?? node, `${node.type} child shape`);
+        for (let index = 0; index < expected.length; index += 1) {
+            const wanted = expected[index];
+            const child = actual[index];
+            const matches = typeof wanted == "string" ? child.text == wanted : child.id == wanted.id;
+            if (!matches)
+                this.fail(child, `${node.type} child shape`);
+        }
+    }
+    /**
+     * Validates one Swift identifier in the portable source profile.
+     * @param {import("tree-sitter").SyntaxNode} node - Identifier token.
+     * @param {boolean} [allowPrint] - Whether the fixed print scaffold is expected.
+     * @returns {string} Accepted spelling.
+     */
+    identifier(node, allowPrint = false) {
+        const name = node.text;
+        if (node.type != "simple_identifier" || !(allowPrint && name == "print") &&
+            (!isSwiftIdentifier(name) || name.normalize("NFC") != name))
+            this.fail(node, "reserved or unsupported identifier");
+        return name;
+    }
+    /**
+     * Converts exactly Int64, Bool, or String.
+     * @param {import("tree-sitter").SyntaxNode} node - Type node.
+     * @returns {import("../semantic/types.js").TypeReference} Semantic scalar.
+     */
+    type(node) {
+        const parts = this.parts(node);
+        if (node.type != "user_type" || parts.length != 1 || parts[0].type != "type_identifier")
+            this.fail(node, "scalar type shape");
+        this.shape(node, [parts[0]]);
+        const type = sourceScalarType("swift", parts[0].text, this.location(parts[0]));
+        if (!type)
+            this.fail(parts[0], `unsupported scalar type '${parts[0].text}'`);
+        return type;
+    }
+    /**
+     * Converts one exact ordinary Swift string literal.
+     * @param {import("tree-sitter").SyntaxNode} node - String node.
+     * @returns {string} Unicode scalar value.
+     */
+    string(node) {
+        const parts = this.parts(node);
+        if (node.type != "line_string_literal" || parts.length < 2 || parts[0].text != '"' || parts.at(-1)?.text != '"') {
+            return this.fail(node, "ordinary noninterpolated string literal required");
+        }
+        this.shape(node, ['"', ...parts.slice(1, -1), '"']);
+        let value = "";
+        const simpleEscapes = new Map([
+            ["\\0", "\0"], ["\\n", "\n"], ["\\r", "\r"], ["\\t", "\t"], ["\\\\", "\\"], ['\\"', '"'], ["\\'", "'"]
+        ]);
+        for (const part of parts.slice(1, -1)) {
+            if (part.type == "line_str_text") {
+                if (/[\r\n]/u.test(part.text))
+                    this.fail(part, "string line terminator");
+                value += part.text;
+            }
+            else if (part.type == "str_escaped_char") {
+                const escape = part.text;
+                if (simpleEscapes.has(escape))
+                    value += simpleEscapes.get(escape);
+                else {
+                    const match = /^\\u\{([0-9A-Fa-f]{1,8})\}$/u.exec(escape);
+                    if (!match)
+                        this.fail(part, "unsupported string escape");
+                    const scalar = Number.parseInt(match[1], 16);
+                    if (scalar > 0x10FFFF || scalar >= 0xD800 && scalar <= 0xDFFF)
+                        this.fail(part, "non-scalar Unicode escape");
+                    value += String.fromCodePoint(scalar);
+                }
+            }
+            else
+                this.fail(part, part.type == "interpolated_expression" ? "interpolated string" : "string child");
+        }
+        if (!hasOnlyUnicodeScalars(value))
+            this.fail(node, "invalid Unicode string literal");
+        return value;
+    }
+    /**
+     * Reads exact unlabeled call arguments.
+     * @param {import("tree-sitter").SyntaxNode} suffix - Call suffix.
+     * @returns {import("tree-sitter").SyntaxNode[]} Argument value nodes.
+     */
+    arguments(suffix) {
+        const suffixParts = this.parts(suffix);
+        if (suffix.type != "call_suffix" || suffixParts.length != 1 || suffixParts[0].type != "value_arguments") {
+            return this.fail(suffix, "call suffix shape");
+        }
+        this.shape(suffix, [suffixParts[0]]);
+        const list = suffixParts[0];
+        const parts = this.parts(list);
+        if (parts.length < 2 || parts[0].text != "(" || parts.at(-1)?.text != ")")
+            this.fail(list, "call argument list shape");
+        const arguments_ = parts.slice(1, -1).filter((_part, index) => index % 2 == 0);
+        const expected = ["(", ...arguments_.flatMap((argument, index) => index == 0 ? [argument] : [",", argument]), ")"];
+        this.shape(list, expected);
+        return arguments_.map((argument) => {
+            const value = this.field(argument, "value");
+            if (argument.type != "value_argument")
+                this.fail(argument, "unlabeled argument required");
+            this.shape(argument, [value]);
+            return value;
+        });
+    }
+    /**
+     * Converts a direct semantic call, including qualified negated-call and trailing-call binary shapes.
+     * @param {import("tree-sitter").SyntaxNode} node - Call node.
+     * @returns {import("../semantic/types.js").Expression} Semantic expression.
+     */
+    call(node) {
+        const location = this.location(node);
+        const parts = this.parts(node);
+        if (node.type != "call_expression" || parts.length != 2)
+            this.fail(node, "direct call shape");
+        const target = parts[0];
+        const suffix = parts[1];
+        if (binaryNodeOperators.has(target.type)) {
+            const right = this.field(target, "rhs");
+            const callLocation = locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, right.startIndex), bindingIndexToUtf16Offset(this.source, suffix.endIndex));
+            if (right.type != "simple_identifier")
+                this.fail(node, "trailing direct call shape");
+            this.shape(node, [target, suffix]);
+            return this.binary(target, undefined, location, this.callParts(right, suffix, callLocation));
+        }
+        return this.callParts(target, suffix, location);
+    }
+    /**
+     * Converts one direct call from its parser target and suffix.
+     * @param {import("tree-sitter").SyntaxNode} target - Direct call target.
+     * @param {import("tree-sitter").SyntaxNode} suffix - Argument suffix.
+     * @param {import("../semantic/types.js").SourceLocation} location - Complete call location.
+     * @returns {import("../semantic/types.js").Expression} Semantic call or prefixed call.
+     */
+    callParts(target, suffix, location) {
+        const argumentNodes = this.arguments(suffix);
+        let nameNode = target;
+        /** @type {import("tree-sitter").SyntaxNode | undefined} */
+        let unaryOperator;
+        if (["!", "-"].includes(nameNode.text)) {
+            if (argumentNodes.length != 1)
+                this.fail(target, "parenthesized unary expression shape");
+            const expression = this.expression(argumentNodes[0]);
+            return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+                kind: "UnaryExpression", location, operand: expression
+            }, { operator: this.location(nameNode) }), nameNode.text == "-" ? "Negate" : "Not")));
+        }
+        if (nameNode.type == "prefix_expression") {
+            const operation = this.field(nameNode, "operation");
+            const target = this.field(nameNode, "target");
+            this.shape(nameNode, [operation, target]);
+            if (!["!", "-"].includes(operation.text) || target.type != "simple_identifier")
+                this.fail(nameNode, "prefixed direct call shape");
+            unaryOperator = operation;
+            nameNode = target;
+        }
+        const name = nameNode.text;
+        const helperOperation = this.helpers.has(name) ? helperOperations.get(name) : undefined;
+        if (helperOperation) {
+            if (unaryOperator || argumentNodes.length != 2)
+                this.fail(target, "Swift scalar equality helper shape");
+            return /** @type {import("../semantic/types.js").Expression} */ (withAdaptedOperation(withParserRanges({
+                kind: "BinaryExpression", left: this.expression(argumentNodes[0]), location, right: this.expression(argumentNodes[1])
+            }, { operator: this.location(nameNode) }), helperOperation));
+        }
+        const semanticName = this.identifier(nameNode);
+        if (argumentNodes.length != 2)
+            this.fail(suffix, "semantic call argument count");
+        const call = withParserRanges({
+            arguments: argumentNodes.map((argument) => this.expression(argument)),
+            callee: semanticName,
+            kind: /** @type {const} */ ("CallExpression"),
+            location
+        }, { callee: this.location(nameNode) });
+        if (!unaryOperator)
+            return call;
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression", location, operand: call
+        }, { operator: this.location(unaryOperator) }), unaryOperator.text == "-" ? "Negate" : "Not")));
+    }
+    /**
+     * Converts one supported scalar expression.
+     * @param {import("tree-sitter").SyntaxNode} node - Expression node.
+     * @returns {import("../semantic/types.js").Expression} Semantic expression.
+     */
+    expression(node) {
+        const location = this.location(node);
+        if (node.type == "simple_identifier") {
+            return withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location, name: this.identifier(node) }, { name: location });
+        }
+        if (node.type == "integer_literal") {
+            if (!/^(?:0|[1-9][0-9]*)$/u.test(node.text))
+                this.fail(node, "noncanonical integer literal");
+            const value = Number(BigInt(node.text));
+            if (!Number.isSafeInteger(value))
+                this.fail(node, "non-safe integer literal");
+            return withParserRanges({ kind: /** @type {const} */ ("IntegerLiteral"), location, value }, { literal: location });
+        }
+        if (node.type == "boolean_literal") {
+            const parts = this.parts(node);
+            if (parts.length != 1 || !["true", "false"].includes(parts[0].text))
+                this.fail(node, "Boolean literal shape");
+            this.shape(node, [parts[0].text]);
+            return withParserRanges({ kind: /** @type {const} */ ("BooleanLiteral"), location, value: parts[0].text == "true" }, { literal: location });
+        }
+        if (node.type == "line_string_literal") {
+            return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: this.string(node) }, { literal: location });
+        }
+        if (node.type == "tuple_expression") {
+            const value = this.field(node, "value");
+            this.shape(node, ["(", value, ")"]);
+            return this.expression(value);
+        }
+        if (node.type == "prefix_expression") {
+            const operation = this.field(node, "operation");
+            const target = this.field(node, "target");
+            this.shape(node, [operation, target]);
+            if (!["-", "!"].includes(operation.text))
+                this.fail(operation, "unary operator");
+            return this.prefixed(operation, target);
+        }
+        const acceptedOperators = binaryNodeOperators.get(node.type);
+        if (acceptedOperators) {
+            return this.binary(node);
+        }
+        if (node.type == "call_expression")
+            return this.call(node);
+        return this.fail(node);
+    }
+    /**
+     * Converts the grammar's broad prefix target with Swift's tighter prefix precedence.
+     * @param {import("tree-sitter").SyntaxNode} operator - Prefix operator.
+     * @param {import("tree-sitter").SyntaxNode} target - Grammar target.
+     * @returns {import("../semantic/types.js").Expression} Semantic expression.
+     */
+    prefixed(operator, target) {
+        const location = locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, operator.startIndex), bindingIndexToUtf16Offset(this.source, target.endIndex));
+        if (binaryNodeOperators.has(target.type)) {
+            const left = this.field(target, "lhs");
+            return this.binary(target, this.prefixed(operator, left), location);
+        }
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression", location, operand: this.expression(target)
+        }, { operator: this.location(operator) }), operator.text == "-" ? "Negate" : "Not")));
+    }
+    /**
+     * Converts one qualified binary node, optionally replacing its left edge for prefix precedence.
+     * @param {import("tree-sitter").SyntaxNode} node - Binary node.
+     * @param {import("../semantic/types.js").Expression} [leftExpression] - Adapted left operand.
+     * @param {import("../semantic/types.js").SourceLocation} [location] - Adapted expression range.
+     * @param {import("../semantic/types.js").Expression} [rightExpression] - Adapted trailing-call right operand.
+     * @returns {import("../semantic/types.js").Expression} Semantic expression.
+     */
+    binary(node, leftExpression, location = this.location(node), rightExpression) {
+        const acceptedOperators = binaryNodeOperators.get(node.type);
+        const left = this.field(node, "lhs");
+        const operator = this.field(node, "op");
+        const right = this.field(node, "rhs");
+        const operation = binaryOperations.get(operator.text);
+        this.shape(node, [left, operator, right]);
+        if (!acceptedOperators?.has(operator.text) || !operation)
+            this.fail(operator, "unsupported binary operator");
+        const expression = /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression", left: leftExpression ?? this.expression(left), location, right: rightExpression ?? this.expression(right)
+        }, { operator: this.location(operator) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (operation))));
+        if (["==", "!="].includes(operator.text))
+            this.nativeEqualityOperators.set(expression, operator);
+        return expression;
+    }
+    /**
+     * Converts one explicitly typed initialized local.
+     * @param {import("tree-sitter").SyntaxNode} node - Property declaration.
+     * @returns {import("../semantic/types.js").LocalDeclaration} Semantic local.
+     */
+    local(node) {
+        const location = this.location(node);
+        const parts = this.parts(node);
+        const binding = parts.find((child) => child.type == "value_binding_pattern");
+        const pattern = node.childForFieldName("name");
+        const annotation = parts.find((child) => child.type == "type_annotation");
+        const value = node.childForFieldName("value");
+        if (!annotation)
+            return missingType("swift", "Local", location);
+        if (!binding || !pattern || !value || pattern.type != "pattern")
+            this.fail(node, "local declaration shape");
+        const bindingParts = this.parts(binding);
+        const nameNode = pattern.childForFieldName("bound_identifier");
+        const annotationParts = this.parts(annotation);
+        if (bindingParts.length != 1 || !["let", "var"].includes(bindingParts[0].text) || !nameNode || annotationParts.length != 2) {
+            this.fail(node, "local declaration shape");
+        }
+        this.shape(binding, [bindingParts[0].text]);
+        this.shape(pattern, [nameNode]);
+        this.shape(annotation, [":", annotationParts[1]]);
+        this.shape(node, [binding, pattern, annotation, "=", value]);
+        const name = this.identifier(nameNode);
+        return withParserRanges({
+            initializer: this.expression(value),
+            kind: /** @type {const} */ ("LocalDeclaration"),
+            location,
+            mutable: bindingParts[0].text == "var",
+            name,
+            type: this.type(annotationParts[1])
+        }, { name: this.location(nameNode), operator: this.location(parts[3]) });
+    }
+    /**
+     * Converts one plain identifier assignment.
+     * @param {import("tree-sitter").SyntaxNode} node - Assignment node.
+     * @returns {import("../semantic/types.js").AssignmentStatement} Semantic assignment.
+     */
+    assignment(node) {
+        const target = this.field(node, "target");
+        const operator = this.field(node, "operator");
+        const value = this.field(node, "result");
+        const targetParts = this.parts(target);
+        if (target.type != "directly_assignable_expression" || targetParts.length != 1 || operator.text != "=") {
+            this.fail(node, "assignment shape");
+        }
+        this.shape(target, [targetParts[0]]);
+        this.shape(node, [target, operator, value]);
+        const name = this.identifier(targetParts[0]);
+        const targetLocation = this.location(targetParts[0]);
+        return withParserRanges({
+            expression: this.expression(value),
+            kind: /** @type {const} */ ("AssignmentStatement"),
+            location: this.location(node),
+            target: withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: targetLocation, name }, { name: targetLocation })
+        }, { operator: this.location(operator) });
+    }
+    /**
+     * Converts one exact print call.
+     * @param {import("tree-sitter").SyntaxNode} node - Call statement.
+     * @returns {import("../semantic/types.js").PrintStatement} Semantic print.
+     */
+    print(node) {
+        const parts = this.parts(node);
+        if (node.type != "call_expression" || parts.length != 2 || parts[0].type != "simple_identifier" ||
+            this.identifier(parts[0], true) != "print")
+            this.fail(node, "exact print call required");
+        const arguments_ = this.arguments(parts[1]);
+        if (arguments_.length != 1)
+            this.fail(parts[1], "print argument count");
+        return { expression: this.expression(arguments_[0]), kind: /** @type {const} */ ("PrintStatement"), location: this.location(node) };
+    }
+    /**
+     * Converts one supported statement.
+     * @param {import("tree-sitter").SyntaxNode} node - Statement node.
+     * @returns {import("../semantic/types.js").Statement} Semantic statement.
+     */
+    statement(node) {
+        if (node.type == "property_declaration")
+            return this.local(node);
+        if (node.type == "assignment")
+            return this.assignment(node);
+        if (node.type == "if_statement")
+            return this.conditional(node);
+        if (node.type == "call_expression")
+            return this.print(node);
+        if (node.type == "control_transfer_statement") {
+            const result = node.childForFieldName("result");
+            if (!result)
+                this.fail(node, "return without expression");
+            this.shape(node, ["return", result]);
+            return { expression: this.expression(result), kind: /** @type {const} */ ("ReturnStatement"), location: this.location(node) };
+        }
+        return this.fail(node);
+    }
+    /**
+     * Converts one parser statements node.
+     * @param {import("tree-sitter").SyntaxNode | undefined} node - Optional statements node.
+     * @returns {import("../semantic/types.js").Statement[]} Ordered statements.
+     */
+    statements(node) {
+        if (!node)
+            return [];
+        if (node.type != "statements")
+            this.fail(node, "statement list shape");
+        return this.statementList(this.parts(node));
+    }
+    /**
+     * Converts a statement sequence while collapsing an adjacent generated marker.
+     * @param {import("tree-sitter").SyntaxNode[]} nodes - Ordered statement nodes.
+     * @returns {import("../semantic/types.js").Statement[]} Semantic statements.
+     */
+    statementList(nodes) {
+        /** @type {import("../semantic/types.js").Statement[]} */
+        const statements = [];
+        for (const statement of nodes) {
+            const parts = this.parts(statement);
+            const marker = statement.type == "call_expression" && parts[0]?.text == "semantifold_keep_mutable";
+            if (marker) {
+                const previous = statements.at(-1);
+                if (!previous || previous.kind != "LocalDeclaration" || !previous.mutable)
+                    this.fail(statement, "Swift mutable-local warning marker");
+                this.mutableMarkerCall(statement, previous);
+            }
+            else
+                statements.push(this.statement(statement));
+        }
+        return statements;
+    }
+    /**
+     * Collapses the generated inout call only beside its declared mutable local.
+     * @param {import("tree-sitter").SyntaxNode} node - Generated marker call.
+     * @param {import("../semantic/types.js").LocalDeclaration} local - Preceding local.
+     * @returns {void}
+     */
+    mutableMarkerCall(node, local) {
+        const parts = this.parts(node);
+        const arguments_ = parts.length == 2 ? this.arguments(parts[1]) : [];
+        const argument = arguments_[0];
+        const target = argument?.type == "prefix_expression" ? this.field(argument, "target") : undefined;
+        if (!this.mutableMarker || parts[0]?.type != "simple_identifier" || parts[0].text != "semantifold_keep_mutable" ||
+            arguments_.length != 1 || !target || target.type != "simple_identifier" || target.text != local.name) {
+            this.fail(node, "Swift mutable-local warning marker");
+        }
+        this.shape(node, [parts[0], parts[1]]);
+        this.shape(argument, ["&", target]);
+    }
+    /**
+     * Converts one exact braced conditional, including direct else-if.
+     * @param {import("tree-sitter").SyntaxNode} node - If node.
+     * @returns {import("../semantic/types.js").IfStatement} Semantic conditional.
+     */
+    conditional(node) {
+        const parts = this.parts(node);
+        const condition = this.field(node, "condition");
+        let index = 3;
+        const consequentStatements = parts[index]?.type == "statements" ? parts[index++] : undefined;
+        if (node.type != "if_statement" || parts[0]?.text != "if" || parts[1]?.id != condition.id || parts[2]?.text != "{" ||
+            parts[index]?.text != "}")
+            this.fail(node, "if statement shape");
+        index += 1;
+        const statement = {
+            condition: this.expression(condition),
+            consequent: { kind: /** @type {const} */ ("Block"), location: this.location(consequentStatements ?? node),
+                statements: this.statements(consequentStatements) },
+            kind: /** @type {const} */ ("IfStatement"),
+            location: this.location(node)
+        };
+        if (index == parts.length) {
+            this.shape(node, ["if", condition, "{", ...(consequentStatements ? [consequentStatements] : []), "}"]);
+            return statement;
+        }
+        if (parts[index]?.text != "else")
+            this.fail(parts[index] ?? node, "if alternate shape");
+        index += 1;
+        const branch = parts[index];
+        if (branch?.type == "if_statement" && index + 1 == parts.length) {
+            this.shape(node, ["if", condition, "{", ...(consequentStatements ? [consequentStatements] : []), "}", "else", branch]);
+            return { ...statement, alternate: { kind: /** @type {const} */ ("Block"), location: this.location(branch), statements: [this.conditional(branch)] } };
+        }
+        if (branch?.text != "{")
+            this.fail(branch ?? node, "if alternate block shape");
+        index += 1;
+        const alternateStatements = parts[index]?.type == "statements" ? parts[index++] : undefined;
+        if (parts[index]?.text != "}" || index + 1 != parts.length)
+            this.fail(parts[index] ?? node, "if alternate block shape");
+        this.shape(node, ["if", condition, "{", ...(consequentStatements ? [consequentStatements] : []), "}", "else", "{",
+            ...(alternateStatements ? [alternateStatements] : []), "}"]);
+        return { ...statement, alternate: { kind: /** @type {const} */ ("Block"), location: this.location(alternateStatements ?? node),
+                statements: this.statements(alternateStatements) } };
+    }
+    /**
+     * Converts one function body.
+     * @param {import("tree-sitter").SyntaxNode} node - Function body.
+     * @returns {import("../semantic/types.js").Block} Semantic block.
+     */
+    block(node) {
+        const parts = this.parts(node);
+        const statements = parts[1]?.type == "statements" ? parts[1] : undefined;
+        if (node.type != "function_body")
+            this.fail(node, "function body shape");
+        this.shape(node, ["{", ...(statements ? [statements] : []), "}"]);
+        return { kind: /** @type {const} */ ("Block"), location: this.location(node), statements: this.statements(statements) };
+    }
+    /**
+     * Converts one exact underscore-labeled parameter.
+     * @param {import("tree-sitter").SyntaxNode} node - Parameter node.
+     * @returns {import("../semantic/types.js").Parameter} Semantic parameter.
+     */
+    parameter(node) {
+        const parts = this.parts(node);
+        if (node.type != "parameter" || parts.length != 4 || parts[0].text != "_" || parts[0].type != "simple_identifier" ||
+            parts[1].type != "simple_identifier" || parts[2].text != ":")
+            this.fail(node, "parameter shape");
+        this.shape(node, [parts[0], parts[1], ":", parts[3]]);
+        const name = this.identifier(parts[1]);
+        return withParserRanges({ kind: /** @type {const} */ ("Parameter"), location: this.location(node), name, type: this.type(parts[3]) }, {
+            name: this.location(parts[1])
+        });
+    }
+    /**
+     * Converts one synchronous top-level scalar function.
+     * @param {import("tree-sitter").SyntaxNode} node - Function node.
+     * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+     */
+    function(node) {
+        const parts = this.parts(node);
+        const nameNode = node.childForFieldName("name");
+        const body = node.childForFieldName("body");
+        const parameters = parts.filter((part) => part.type == "parameter");
+        if (!nameNode || !body || node.type != "function_declaration")
+            this.fail(node, "function declaration shape");
+        if (parameters.length != 2)
+            this.fail(node, "function parameter count other than two");
+        if (!parts.some((part) => part.text == "->"))
+            return missingType("swift", "Function return", this.location(node));
+        if (parts.length != 10)
+            this.fail(parts.find((part) => !["func", "(", ",", ")", "->"].includes(part.text) &&
+                part.id != nameNode.id && part.id != body.id && !parameters.some((parameter) => parameter.id == part.id)) ?? node, "function declaration shape");
+        const returnType = parts[8];
+        this.shape(node, ["func", nameNode, "(", parameters[0], ",", parameters[1], ")", "->", returnType, body]);
+        const name = this.identifier(nameNode);
+        return withParserRanges({
+            body: this.block(body),
+            kind: /** @type {const} */ ("FunctionDeclaration"),
+            location: this.location(node),
+            name,
+            parameters: parameters.map((parameter) => this.parameter(parameter)),
+            returnType: this.type(returnType)
+        }, { name: this.location(nameNode) });
+    }
+    /**
+     * Compares every child field and leaf token against target-only canonical support.
+     * @param {import("tree-sitter").SyntaxNode} actual - Source support node.
+     * @param {import("tree-sitter").SyntaxNode} expected - Canonical support node.
+     * @param {SwiftReader} canonical - Canonical source reader.
+     * @returns {void}
+     */
+    compareTree(actual, expected, canonical) {
+        if (actual.type != expected.type || actual.isNamed != expected.isNamed || actual.isExtra != expected.isExtra ||
+            actual.childCount != expected.childCount)
+            this.fail(actual, "modified Swift support node");
+        if (!actual.childCount && actual.text != expected.text)
+            this.fail(actual, "modified Swift support token");
+        for (let index = 0; index < actual.childCount; index += 1) {
+            const left = actual.child(index);
+            const right = expected.child(index);
+            if (!left || !right || actual.fieldNameForChild(index) != expected.fieldNameForChild(index)) {
+                this.fail(left ?? actual, "modified Swift support field");
+            }
+            this.compareTree(left, right, canonical);
+        }
+    }
+    /**
+     * Rejects ordinary Swift equality after shared type resolution identifies Strings.
+     * @param {import("../semantic/types.js").SemanticModule} module - Validated semantic module.
+     * @returns {void}
+     */
+    rejectNativeStringEquality(module) {
+        const pending = [module.entryPoint.body, ...module.functions.map((declaration) => declaration.body)];
+        while (pending.length) {
+            const block = pending.pop();
+            if (!block)
+                throw new Error("Swift semantic traversal lost a pending block.");
+            for (const statement of block.statements) {
+                if (statement.kind == "IfStatement") {
+                    pending.push(statement.consequent);
+                    if (statement.alternate)
+                        pending.push(statement.alternate);
+                    this.rejectNativeStringEqualityExpression(statement.condition);
+                }
+                else if (statement.kind == "LocalDeclaration")
+                    this.rejectNativeStringEqualityExpression(statement.initializer);
+                else if (statement.kind == "AssignmentStatement")
+                    this.rejectNativeStringEqualityExpression(statement.expression);
+                else if (statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement") {
+                    this.rejectNativeStringEqualityExpression(statement.expression);
+                }
+                else if (statement.kind == "ReturnStatement" && statement.expression) {
+                    this.rejectNativeStringEqualityExpression(statement.expression);
+                }
+            }
+        }
+    }
+    /**
+     * Checks one validated expression without retaining parser state in public values.
+     * @param {import("../semantic/types.js").Expression} root - Validated expression.
+     * @returns {void}
+     */
+    rejectNativeStringEqualityExpression(root) {
+        const pending = [root];
+        while (pending.length) {
+            const expression = pending.pop();
+            if (!expression)
+                throw new Error("Swift semantic traversal lost a pending expression.");
+            if (expression.kind == "BinaryExpression") {
+                const operator = this.nativeEqualityOperators.get(expression);
+                if (operator && ["StringEqual", "StringNotEqual"].includes(expression.operation)) {
+                    this.fail(operator, "ordinary Swift String equality");
+                }
+                pending.push(expression.left, expression.right);
+            }
+            else if (expression.kind == "UnaryExpression")
+                pending.push(expression.operand);
+            else if (expression.kind == "CallExpression")
+                pending.push(...expression.arguments);
+        }
+    }
+    /**
+     * Converts the complete source file with declarations before top-level entry statements.
+     * @param {import("tree-sitter").SyntaxNode} root - Source root.
+     * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+     */
+    module(root) {
+        this.validateTree(root);
+        if (root.type != "source_file")
+            this.fail(root, "source file root");
+        const parts = this.parts(root);
+        const canonical = new SwiftReader(this.filename, swiftRuntime);
+        const support = canonical.parts(parser.parse(swiftRuntime).rootNode);
+        let supportIndex = 0;
+        while (supportIndex < parts.length && supportIndex < support.length) {
+            const node = parts[supportIndex];
+            const name = node.type == "function_declaration" ? node.childForFieldName("name") : undefined;
+            const expectedName = support[supportIndex].childForFieldName("name");
+            if (!name || !expectedName || name.text != expectedName.text)
+                break;
+            this.compareTree(node, support[supportIndex], canonical);
+            if (helperOperations.has(name.text))
+                this.helpers.add(name.text);
+            else if (name.text == "semantifold_keep_mutable")
+                this.mutableMarker = true;
+            supportIndex += 1;
+        }
+        if (supportIndex > 0 && supportIndex != support.length)
+            this.fail(parts[supportIndex - 1], "complete Swift support required");
+        const semanticParts = parts.slice(supportIndex);
+        const firstEntry = semanticParts.findIndex((node) => node.type != "function_declaration");
+        const split = firstEntry < 0 ? semanticParts.length : firstEntry;
+        const declarations = semanticParts.slice(0, split);
+        const entries = semanticParts.slice(split);
+        if (!declarations.length)
+            this.fail(root, "top-level semantic function required");
+        const laterFunction = entries.find((node) => node.type == "function_declaration");
+        const unsupportedEntry = entries.find((node) => !["assignment", "call_expression", "control_transfer_statement", "if_statement",
+            "property_declaration", "function_declaration"].includes(node.type));
+        if (unsupportedEntry)
+            this.fail(unsupportedEntry);
+        if (laterFunction)
+            this.fail(laterFunction, "function declaration after entry statement");
+        if (!entries.length)
+            this.fail(root, "top-level entry/print shell required");
+        const module = {
+            entryPoint: { body: { kind: /** @type {const} */ ("Block"), location: this.location(root),
+                    statements: this.statementList(entries) }, kind: /** @type {const} */ ("EntryPoint"), location: this.location(root) },
+            functions: declarations.map((declaration) => this.function(declaration)),
+            kind: /** @type {const} */ ("Module"),
+            location: this.location(root)
+        };
+        validateParsedModule(module, "swift");
+        this.rejectNativeStringEquality(module);
+        return module;
+    }
+}
+/**
+ * Parses the strict Task 022 Swift profile through the qualified grammar.
+ * @param {{filename: string, source: string}} input - Exact source request.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parseSwift({ filename, source }) {
+    if (!hasOnlyUnicodeScalars(source)) {
+        const offset = firstLoneSurrogateOffset(source);
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR",
+            language: "swift",
+            location: locationFromOffsets(filename, source, offset, offset + 1),
+            message: "Swift source contains an invalid lone UTF-16 surrogate."
+        });
+    }
+    let tree;
+    try {
+        tree = parser.parse(source);
+    }
+    catch (error) {
+        throw new SemantifoldDiagnostic({
+            cause: error instanceof Error ? error : undefined,
+            code: "PARSE_ERROR",
+            language: "swift",
+            location: moduleLocation(filename, source),
+            message: "The qualified Swift parser could not produce a complete CST."
+        });
+    }
+    return new SwiftReader(filename, source).module(tree.rootNode);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"swift.js","sourceRoot":"","sources":["../../../src/frontends/swift.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Parser from \"tree-sitter\"\nimport SwiftLanguage from \"tree-sitter-swift/bindings/node/index.js\"\nimport {isSwiftIdentifier} from \"../backends/identifiers.js\"\nimport {swiftRuntime} from \"../backends/swift-runtime.js\"\nimport {missingType, SemantifoldDiagnostic, unsupportedSyntax} from \"../diagnostic.js\"\nimport {locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset} 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\"\n\nconst parser = new Parser()\n\nparser.setLanguage(/** @type {import(\"tree-sitter\").Language} */ (/** @type {unknown} */ (SwiftLanguage)))\n\nconst binaryOperations = new Map([\n  [\"+\", \"Add\"], [\"-\", \"Subtract\"], [\"*\", \"Multiply\"], [\"==\", \"Equal\"], [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"], [\"<=\", \"LessThanOrEqual\"], [\">\", \"GreaterThan\"], [\">=\", \"GreaterThanOrEqual\"],\n  [\"&&\", \"And\"], [\"||\", \"Or\"]\n])\nconst binaryNodeOperators = new Map([\n  [\"additive_expression\", new Set([\"+\", \"-\"])],\n  [\"multiplicative_expression\", new Set([\"*\"])],\n  [\"equality_expression\", new Set([\"==\"])],\n  [\"comparison_expression\", new Set([\"<\", \">\"])],\n  [\"conjunction_expression\", new Set([\"&&\"])],\n  [\"disjunction_expression\", new Set([\"||\"])],\n  [\"infix_expression\", new Set([\"!=\", \"<=\", \">=\"])]\n])\n/** @type {Map<string, import(\"../semantic/operators.js\").AdaptedOperation>} */\nconst helperOperations = new Map([\n  [\"semantifold_string_equal\", \"StringEqual\"], [\"semantifold_string_not_equal\", \"StringNotEqual\"]\n])\n/**\n * Verifies a Tree-sitter binding index through the shared byte converter.\n * @param {string} source - Complete source.\n * @param {number} index - Binding-reported UTF-16 index.\n * @returns {number} Verified UTF-16 offset.\n */\nfunction bindingIndexToUtf16Offset(source, index) {\n  if (!Number.isInteger(index) || index < 0 || index > source.length ||\n    index > 0 && index < source.length && /[\\uD800-\\uDBFF]/u.test(source[index - 1]) && /[\\uDC00-\\uDFFF]/u.test(source[index])) {\n    throw new RangeError(\"Invalid Tree-sitter source index: \" + index)\n  }\n  return utf8ByteOffsetToUtf16Offset(source, new TextEncoder().encode(source.slice(0, index)).length)\n}\n\n/**\n * Finds an unpaired UTF-16 surrogate.\n * @param {string} source - Complete source.\n * @returns {number} Invalid offset or -1.\n */\nfunction firstLoneSurrogateOffset(source) {\n  for (let index = 0; index < source.length; index += 1) {\n    const unit = source.charCodeAt(index)\n\n    if (unit >= 0xD800 && unit <= 0xDBFF) {\n      const next = source.charCodeAt(index + 1)\n\n      if (next >= 0xDC00 && next <= 0xDFFF) index += 1\n      else return index\n    } else if (unit >= 0xDC00 && unit <= 0xDFFF) return index\n  }\n  return -1\n}\n\n/** Consumes exact qualified Swift CST shapes without retaining parser handles. */\nclass SwiftReader {\n  /**\n   * Creates a reader over one parser-owned Swift source.\n   * @param {string} filename - Original filename.\n   * @param {string} source - Complete source.\n   */\n  constructor(filename, source) {\n    this.filename = filename\n    this.source = source\n    /** @type {Set<string>} */\n    this.helpers = new Set()\n    this.mutableMarker = false\n    /** @type {WeakMap<object, import(\"tree-sitter\").SyntaxNode>} */\n    this.nativeEqualityOperators = new WeakMap()\n  }\n\n  /**\n   * Converts one parser range to Semantifold UTF-16 coordinates.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Parser node.\n   * @returns {import(\"../semantic/types.js\").SourceLocation} Exact location.\n   */\n  location(node) {\n    return locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, node.startIndex),\n      bindingIndexToUtf16Offset(this.source, node.endIndex))\n  }\n\n  /**\n   * Rejects one located source-profile violation.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Violating node.\n   * @param {string} [detail] - Profile detail.\n   * @returns {never} Always throws.\n   */\n  fail(node, detail = node.type) {\n    unsupportedSyntax(\"swift\", detail, this.location(node))\n  }\n\n  /**\n   * Traverses every named, anonymous, extra, directive, and recovery node.\n   * @param {import(\"tree-sitter\").SyntaxNode} root - Complete parser root.\n   * @returns {void}\n   */\n  validateTree(root) {\n    const pending = [{depth: 0, node: root, visited: false}]\n\n    while (pending.length) {\n      const current = pending.pop()\n\n      if (!current) throw new Error(\"Swift traversal lost a pending parser node.\")\n      const {depth, node, visited} = current\n\n      if (depth > 512) this.fail(node, \"CST exceeds the 512-level traversal limit\")\n      if (!visited) {\n        pending.push({depth, node, visited: true})\n        for (let index = node.childCount - 1; index >= 0; index -= 1) {\n          const child = node.child(index)\n\n          if (!child) throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`)\n          pending.push({depth: depth + 1, node: child, visited: false})\n        }\n        continue\n      }\n      if (node.hasError || node.isError || node.isMissing) {\n        throw new SemantifoldDiagnostic({\n          code: \"PARSE_ERROR\",\n          language: \"swift\",\n          location: this.location(node),\n          message: `Tree-sitter exposed recovery at '${node.type}'.`\n        })\n      }\n      if ([\"attribute\", \"directive\", \"shebang_line\"].includes(node.type)) this.fail(node, node.type)\n      if (node.type == \"comment\" && /swift-tools-version/u.test(node.text)) {\n        this.fail(node, \"directive-bearing comment\")\n      }\n    }\n  }\n\n  /**\n   * Omits only inert comments already accounted for by exhaustive traversal.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Parent node.\n   * @returns {import(\"tree-sitter\").SyntaxNode[]} Structural children.\n   */\n  parts(node) {\n    return node.children.filter((child) => child.type != \"comment\")\n  }\n\n  /**\n   * Requires one exact parser field edge.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Field owner.\n   * @param {string} name - Field name.\n   * @returns {import(\"tree-sitter\").SyntaxNode} Sole field node.\n   */\n  field(node, name) {\n    const matches = []\n\n    for (let index = 0; index < node.childCount; index += 1) {\n      const child = node.child(index)\n\n      if (!child) throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`)\n      if (node.fieldNameForChild(index) == name) matches.push(child)\n    }\n    if (matches.length != 1) this.fail(node, `expected one '${name}' field`)\n    return matches[0]\n  }\n\n  /**\n   * Requires all ordered children, including anonymous punctuation.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Shape owner.\n   * @param {(import(\"tree-sitter\").SyntaxNode | string)[]} expected - Exact child sequence.\n   * @returns {void}\n   */\n  shape(node, expected) {\n    const actual = this.parts(node)\n\n    if (actual.length != expected.length) this.fail(actual[Math.min(actual.length, expected.length)] ?? node, `${node.type} child shape`)\n    for (let index = 0; index < expected.length; index += 1) {\n      const wanted = expected[index]\n      const child = actual[index]\n      const matches = typeof wanted == \"string\" ? child.text == wanted : child.id == wanted.id\n\n      if (!matches) this.fail(child, `${node.type} child shape`)\n    }\n  }\n\n  /**\n   * Validates one Swift identifier in the portable source profile.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Identifier token.\n   * @param {boolean} [allowPrint] - Whether the fixed print scaffold is expected.\n   * @returns {string} Accepted spelling.\n   */\n  identifier(node, allowPrint = false) {\n    const name = node.text\n\n    if (node.type != \"simple_identifier\" || !(allowPrint && name == \"print\") &&\n      (!isSwiftIdentifier(name) || name.normalize(\"NFC\") != name)) this.fail(node, \"reserved or unsupported identifier\")\n    return name\n  }\n\n  /**\n   * Converts exactly Int64, Bool, or String.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Type node.\n   * @returns {import(\"../semantic/types.js\").TypeReference} Semantic scalar.\n   */\n  type(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"user_type\" || parts.length != 1 || parts[0].type != \"type_identifier\") this.fail(node, \"scalar type shape\")\n    this.shape(node, [parts[0]])\n    const type = sourceScalarType(\"swift\", parts[0].text, this.location(parts[0]))\n\n    if (!type) this.fail(parts[0], `unsupported scalar type '${parts[0].text}'`)\n    return type\n  }\n\n  /**\n   * Converts one exact ordinary Swift string literal.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - String node.\n   * @returns {string} Unicode scalar value.\n   */\n  string(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"line_string_literal\" || parts.length < 2 || parts[0].text != '\"' || parts.at(-1)?.text != '\"') {\n      return this.fail(node, \"ordinary noninterpolated string literal required\")\n    }\n    this.shape(node, ['\"', ...parts.slice(1, -1), '\"'])\n    let value = \"\"\n    const simpleEscapes = new Map([\n      [\"\\\\0\", \"\\0\"], [\"\\\\n\", \"\\n\"], [\"\\\\r\", \"\\r\"], [\"\\\\t\", \"\\t\"], [\"\\\\\\\\\", \"\\\\\"], ['\\\\\"', '\"'], [\"\\\\'\", \"'\"]\n    ])\n\n    for (const part of parts.slice(1, -1)) {\n      if (part.type == \"line_str_text\") {\n        if (/[\\r\\n]/u.test(part.text)) this.fail(part, \"string line terminator\")\n        value += part.text\n      } else if (part.type == \"str_escaped_char\") {\n        const escape = part.text\n\n        if (simpleEscapes.has(escape)) value += simpleEscapes.get(escape)\n        else {\n          const match = /^\\\\u\\{([0-9A-Fa-f]{1,8})\\}$/u.exec(escape)\n\n          if (!match) this.fail(part, \"unsupported string escape\")\n          const scalar = Number.parseInt(match[1], 16)\n\n          if (scalar > 0x10FFFF || scalar >= 0xD800 && scalar <= 0xDFFF) this.fail(part, \"non-scalar Unicode escape\")\n          value += String.fromCodePoint(scalar)\n        }\n      } else this.fail(part, part.type == \"interpolated_expression\" ? \"interpolated string\" : \"string child\")\n    }\n    if (!hasOnlyUnicodeScalars(value)) this.fail(node, \"invalid Unicode string literal\")\n    return value\n  }\n\n  /**\n   * Reads exact unlabeled call arguments.\n   * @param {import(\"tree-sitter\").SyntaxNode} suffix - Call suffix.\n   * @returns {import(\"tree-sitter\").SyntaxNode[]} Argument value nodes.\n   */\n  arguments(suffix) {\n    const suffixParts = this.parts(suffix)\n\n    if (suffix.type != \"call_suffix\" || suffixParts.length != 1 || suffixParts[0].type != \"value_arguments\") {\n      return this.fail(suffix, \"call suffix shape\")\n    }\n    this.shape(suffix, [suffixParts[0]])\n    const list = suffixParts[0]\n    const parts = this.parts(list)\n\n    if (parts.length < 2 || parts[0].text != \"(\" || parts.at(-1)?.text != \")\") this.fail(list, \"call argument list shape\")\n    const arguments_ = parts.slice(1, -1).filter((_part, index) => index % 2 == 0)\n    const expected = [\"(\", ...arguments_.flatMap((argument, index) => index == 0 ? [argument] : [\",\", argument]), \")\"]\n\n    this.shape(list, expected)\n    return arguments_.map((argument) => {\n      const value = this.field(argument, \"value\")\n\n      if (argument.type != \"value_argument\") this.fail(argument, \"unlabeled argument required\")\n      this.shape(argument, [value])\n      return value\n    })\n  }\n\n  /**\n   * Converts a direct semantic call, including qualified negated-call and trailing-call binary shapes.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Call node.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n   */\n  call(node) {\n    const location = this.location(node)\n    const parts = this.parts(node)\n\n    if (node.type != \"call_expression\" || parts.length != 2) this.fail(node, \"direct call shape\")\n    const target = parts[0]\n    const suffix = parts[1]\n\n    if (binaryNodeOperators.has(target.type)) {\n      const right = this.field(target, \"rhs\")\n      const callLocation = locationFromOffsets(this.filename, this.source,\n        bindingIndexToUtf16Offset(this.source, right.startIndex), bindingIndexToUtf16Offset(this.source, suffix.endIndex))\n\n      if (right.type != \"simple_identifier\") this.fail(node, \"trailing direct call shape\")\n      this.shape(node, [target, suffix])\n\n      return this.binary(target, undefined, location, this.callParts(right, suffix, callLocation))\n    }\n\n    return this.callParts(target, suffix, location)\n  }\n\n  /**\n   * Converts one direct call from its parser target and suffix.\n   * @param {import(\"tree-sitter\").SyntaxNode} target - Direct call target.\n   * @param {import(\"tree-sitter\").SyntaxNode} suffix - Argument suffix.\n   * @param {import(\"../semantic/types.js\").SourceLocation} location - Complete call location.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic call or prefixed call.\n   */\n  callParts(target, suffix, location) {\n    const argumentNodes = this.arguments(suffix)\n    let nameNode = target\n    /** @type {import(\"tree-sitter\").SyntaxNode | undefined} */\n    let unaryOperator\n\n    if ([\"!\", \"-\"].includes(nameNode.text)) {\n      if (argumentNodes.length != 1) this.fail(target, \"parenthesized unary expression shape\")\n      const expression = this.expression(argumentNodes[0])\n\n      return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n        kind: \"UnaryExpression\", location, operand: expression\n      }, {operator: this.location(nameNode)}), nameNode.text == \"-\" ? \"Negate\" : \"Not\")))\n    }\n    if (nameNode.type == \"prefix_expression\") {\n      const operation = this.field(nameNode, \"operation\")\n      const target = this.field(nameNode, \"target\")\n\n      this.shape(nameNode, [operation, target])\n      if (![\"!\", \"-\"].includes(operation.text) || target.type != \"simple_identifier\") this.fail(nameNode, \"prefixed direct call shape\")\n      unaryOperator = operation\n      nameNode = target\n    }\n    const name = nameNode.text\n\n    const helperOperation = this.helpers.has(name) ? helperOperations.get(name) : undefined\n\n    if (helperOperation) {\n      if (unaryOperator || argumentNodes.length != 2) this.fail(target, \"Swift scalar equality helper shape\")\n      return /** @type {import(\"../semantic/types.js\").Expression} */ (withAdaptedOperation(withParserRanges({\n        kind: \"BinaryExpression\", left: this.expression(argumentNodes[0]), location, right: this.expression(argumentNodes[1])\n      }, {operator: this.location(nameNode)}), helperOperation))\n    }\n    const semanticName = this.identifier(nameNode)\n\n    if (argumentNodes.length != 2) this.fail(suffix, \"semantic call argument count\")\n    const call = withParserRanges({\n      arguments: argumentNodes.map((argument) => this.expression(argument)),\n      callee: semanticName,\n      kind: /** @type {const} */ (\"CallExpression\"),\n      location\n    }, {callee: this.location(nameNode)})\n\n    if (!unaryOperator) return call\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\", location, operand: call\n    }, {operator: this.location(unaryOperator)}), unaryOperator.text == \"-\" ? \"Negate\" : \"Not\")))\n  }\n\n  /**\n   * Converts one supported scalar expression.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Expression node.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n   */\n  expression(node) {\n    const location = this.location(node)\n\n    if (node.type == \"simple_identifier\") {\n      return withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location, name: this.identifier(node)}, {name: location})\n    }\n    if (node.type == \"integer_literal\") {\n      if (!/^(?:0|[1-9][0-9]*)$/u.test(node.text)) this.fail(node, \"noncanonical integer literal\")\n      const value = Number(BigInt(node.text))\n\n      if (!Number.isSafeInteger(value)) this.fail(node, \"non-safe integer literal\")\n      return withParserRanges({kind: /** @type {const} */ (\"IntegerLiteral\"), location, value}, {literal: location})\n    }\n    if (node.type == \"boolean_literal\") {\n      const parts = this.parts(node)\n\n      if (parts.length != 1 || ![\"true\", \"false\"].includes(parts[0].text)) this.fail(node, \"Boolean literal shape\")\n      this.shape(node, [parts[0].text])\n      return withParserRanges({kind: /** @type {const} */ (\"BooleanLiteral\"), location, value: parts[0].text == \"true\"}, {literal: location})\n    }\n    if (node.type == \"line_string_literal\") {\n      return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: this.string(node)}, {literal: location})\n    }\n    if (node.type == \"tuple_expression\") {\n      const value = this.field(node, \"value\")\n\n      this.shape(node, [\"(\", value, \")\"])\n      return this.expression(value)\n    }\n    if (node.type == \"prefix_expression\") {\n      const operation = this.field(node, \"operation\")\n      const target = this.field(node, \"target\")\n\n      this.shape(node, [operation, target])\n      if (![\"-\", \"!\"].includes(operation.text)) this.fail(operation, \"unary operator\")\n      return this.prefixed(operation, target)\n    }\n    const acceptedOperators = binaryNodeOperators.get(node.type)\n\n    if (acceptedOperators) {\n      return this.binary(node)\n    }\n    if (node.type == \"call_expression\") return this.call(node)\n    return this.fail(node)\n  }\n\n  /**\n   * Converts the grammar's broad prefix target with Swift's tighter prefix precedence.\n   * @param {import(\"tree-sitter\").SyntaxNode} operator - Prefix operator.\n   * @param {import(\"tree-sitter\").SyntaxNode} target - Grammar target.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n   */\n  prefixed(operator, target) {\n    const location = locationFromOffsets(this.filename, this.source,\n      bindingIndexToUtf16Offset(this.source, operator.startIndex), bindingIndexToUtf16Offset(this.source, target.endIndex))\n\n    if (binaryNodeOperators.has(target.type)) {\n      const left = this.field(target, \"lhs\")\n\n      return this.binary(target, this.prefixed(operator, left), location)\n    }\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\", location, operand: this.expression(target)\n    }, {operator: this.location(operator)}), operator.text == \"-\" ? \"Negate\" : \"Not\")))\n  }\n\n  /**\n   * Converts one qualified binary node, optionally replacing its left edge for prefix precedence.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Binary node.\n   * @param {import(\"../semantic/types.js\").Expression} [leftExpression] - Adapted left operand.\n   * @param {import(\"../semantic/types.js\").SourceLocation} [location] - Adapted expression range.\n   * @param {import(\"../semantic/types.js\").Expression} [rightExpression] - Adapted trailing-call right operand.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n   */\n  binary(node, leftExpression, location = this.location(node), rightExpression) {\n    const acceptedOperators = binaryNodeOperators.get(node.type)\n    const left = this.field(node, \"lhs\")\n    const operator = this.field(node, \"op\")\n    const right = this.field(node, \"rhs\")\n    const operation = binaryOperations.get(operator.text)\n\n    this.shape(node, [left, operator, right])\n    if (!acceptedOperators?.has(operator.text) || !operation) this.fail(operator, \"unsupported binary operator\")\n    const expression = /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\", left: leftExpression ?? this.expression(left), location, right: rightExpression ?? this.expression(right)\n    }, {operator: this.location(operator)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (operation))))\n\n    if ([\"==\", \"!=\"].includes(operator.text)) this.nativeEqualityOperators.set(expression, operator)\n    return expression\n  }\n\n  /**\n   * Converts one explicitly typed initialized local.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Property declaration.\n   * @returns {import(\"../semantic/types.js\").LocalDeclaration} Semantic local.\n   */\n  local(node) {\n    const location = this.location(node)\n    const parts = this.parts(node)\n    const binding = parts.find((child) => child.type == \"value_binding_pattern\")\n    const pattern = node.childForFieldName(\"name\")\n    const annotation = parts.find((child) => child.type == \"type_annotation\")\n    const value = node.childForFieldName(\"value\")\n\n    if (!annotation) return missingType(\"swift\", \"Local\", location)\n    if (!binding || !pattern || !value || pattern.type != \"pattern\") this.fail(node, \"local declaration shape\")\n    const bindingParts = this.parts(binding)\n    const nameNode = pattern.childForFieldName(\"bound_identifier\")\n    const annotationParts = this.parts(annotation)\n\n    if (bindingParts.length != 1 || ![\"let\", \"var\"].includes(bindingParts[0].text) || !nameNode || annotationParts.length != 2) {\n      this.fail(node, \"local declaration shape\")\n    }\n    this.shape(binding, [bindingParts[0].text])\n    this.shape(pattern, [nameNode])\n    this.shape(annotation, [\":\", annotationParts[1]])\n    this.shape(node, [binding, pattern, annotation, \"=\", value])\n    const name = this.identifier(nameNode)\n\n    return withParserRanges({\n      initializer: this.expression(value),\n      kind: /** @type {const} */ (\"LocalDeclaration\"),\n      location,\n      mutable: bindingParts[0].text == \"var\",\n      name,\n      type: this.type(annotationParts[1])\n    }, {name: this.location(nameNode), operator: this.location(parts[3])})\n  }\n\n  /**\n   * Converts one plain identifier assignment.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Assignment node.\n   * @returns {import(\"../semantic/types.js\").AssignmentStatement} Semantic assignment.\n   */\n  assignment(node) {\n    const target = this.field(node, \"target\")\n    const operator = this.field(node, \"operator\")\n    const value = this.field(node, \"result\")\n    const targetParts = this.parts(target)\n\n    if (target.type != \"directly_assignable_expression\" || targetParts.length != 1 || operator.text != \"=\") {\n      this.fail(node, \"assignment shape\")\n    }\n    this.shape(target, [targetParts[0]])\n    this.shape(node, [target, operator, value])\n    const name = this.identifier(targetParts[0])\n    const targetLocation = this.location(targetParts[0])\n\n    return withParserRanges({\n      expression: this.expression(value),\n      kind: /** @type {const} */ (\"AssignmentStatement\"),\n      location: this.location(node),\n      target: withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: targetLocation, name}, {name: targetLocation})\n    }, {operator: this.location(operator)})\n  }\n\n  /**\n   * Converts one exact print call.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Call statement.\n   * @returns {import(\"../semantic/types.js\").PrintStatement} Semantic print.\n   */\n  print(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"call_expression\" || parts.length != 2 || parts[0].type != \"simple_identifier\" ||\n      this.identifier(parts[0], true) != \"print\") this.fail(node, \"exact print call required\")\n    const arguments_ = this.arguments(parts[1])\n\n    if (arguments_.length != 1) this.fail(parts[1], \"print argument count\")\n    return {expression: this.expression(arguments_[0]), kind: /** @type {const} */ (\"PrintStatement\"), location: this.location(node)}\n  }\n\n  /**\n   * Converts one supported statement.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Statement node.\n   * @returns {import(\"../semantic/types.js\").Statement} Semantic statement.\n   */\n  statement(node) {\n    if (node.type == \"property_declaration\") return this.local(node)\n    if (node.type == \"assignment\") return this.assignment(node)\n    if (node.type == \"if_statement\") return this.conditional(node)\n    if (node.type == \"call_expression\") return this.print(node)\n    if (node.type == \"control_transfer_statement\") {\n      const result = node.childForFieldName(\"result\")\n\n      if (!result) this.fail(node, \"return without expression\")\n      this.shape(node, [\"return\", result])\n      return {expression: this.expression(result), kind: /** @type {const} */ (\"ReturnStatement\"), location: this.location(node)}\n    }\n    return this.fail(node)\n  }\n\n  /**\n   * Converts one parser statements node.\n   * @param {import(\"tree-sitter\").SyntaxNode | undefined} node - Optional statements node.\n   * @returns {import(\"../semantic/types.js\").Statement[]} Ordered statements.\n   */\n  statements(node) {\n    if (!node) return []\n    if (node.type != \"statements\") this.fail(node, \"statement list shape\")\n    return this.statementList(this.parts(node))\n  }\n\n  /**\n   * Converts a statement sequence while collapsing an adjacent generated marker.\n   * @param {import(\"tree-sitter\").SyntaxNode[]} nodes - Ordered statement nodes.\n   * @returns {import(\"../semantic/types.js\").Statement[]} Semantic statements.\n   */\n  statementList(nodes) {\n    /** @type {import(\"../semantic/types.js\").Statement[]} */\n    const statements = []\n\n    for (const statement of nodes) {\n      const parts = this.parts(statement)\n      const marker = statement.type == \"call_expression\" && parts[0]?.text == \"semantifold_keep_mutable\"\n\n      if (marker) {\n        const previous = statements.at(-1)\n\n        if (!previous || previous.kind != \"LocalDeclaration\" || !previous.mutable) this.fail(statement, \"Swift mutable-local warning marker\")\n        this.mutableMarkerCall(statement, previous)\n      } else statements.push(this.statement(statement))\n    }\n    return statements\n  }\n\n  /**\n   * Collapses the generated inout call only beside its declared mutable local.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Generated marker call.\n   * @param {import(\"../semantic/types.js\").LocalDeclaration} local - Preceding local.\n   * @returns {void}\n   */\n  mutableMarkerCall(node, local) {\n    const parts = this.parts(node)\n    const arguments_ = parts.length == 2 ? this.arguments(parts[1]) : []\n    const argument = arguments_[0]\n    const target = argument?.type == \"prefix_expression\" ? this.field(argument, \"target\") : undefined\n\n    if (!this.mutableMarker || parts[0]?.type != \"simple_identifier\" || parts[0].text != \"semantifold_keep_mutable\" ||\n      arguments_.length != 1 || !target || target.type != \"simple_identifier\" || target.text != local.name) {\n      this.fail(node, \"Swift mutable-local warning marker\")\n    }\n    this.shape(node, [parts[0], parts[1]])\n    this.shape(argument, [\"&\", target])\n  }\n\n  /**\n   * Converts one exact braced conditional, including direct else-if.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - If node.\n   * @returns {import(\"../semantic/types.js\").IfStatement} Semantic conditional.\n   */\n  conditional(node) {\n    const parts = this.parts(node)\n    const condition = this.field(node, \"condition\")\n    let index = 3\n    const consequentStatements = parts[index]?.type == \"statements\" ? parts[index++] : undefined\n\n    if (node.type != \"if_statement\" || parts[0]?.text != \"if\" || parts[1]?.id != condition.id || parts[2]?.text != \"{\" ||\n      parts[index]?.text != \"}\") this.fail(node, \"if statement shape\")\n    index += 1\n    const statement = {\n      condition: this.expression(condition),\n      consequent: {kind: /** @type {const} */ (\"Block\"), location: this.location(consequentStatements ?? node),\n        statements: this.statements(consequentStatements)},\n      kind: /** @type {const} */ (\"IfStatement\"),\n      location: this.location(node)\n    }\n\n    if (index == parts.length) {\n      this.shape(node, [\"if\", condition, \"{\", ...(consequentStatements ? [consequentStatements] : []), \"}\"])\n      return statement\n    }\n    if (parts[index]?.text != \"else\") this.fail(parts[index] ?? node, \"if alternate shape\")\n    index += 1\n    const branch = parts[index]\n\n    if (branch?.type == \"if_statement\" && index + 1 == parts.length) {\n      this.shape(node, [\"if\", condition, \"{\", ...(consequentStatements ? [consequentStatements] : []), \"}\", \"else\", branch])\n      return {...statement, alternate: {kind: /** @type {const} */ (\"Block\"), location: this.location(branch), statements: [this.conditional(branch)]}}\n    }\n    if (branch?.text != \"{\") this.fail(branch ?? node, \"if alternate block shape\")\n    index += 1\n    const alternateStatements = parts[index]?.type == \"statements\" ? parts[index++] : undefined\n\n    if (parts[index]?.text != \"}\" || index + 1 != parts.length) this.fail(parts[index] ?? node, \"if alternate block shape\")\n    this.shape(node, [\"if\", condition, \"{\", ...(consequentStatements ? [consequentStatements] : []), \"}\", \"else\", \"{\",\n      ...(alternateStatements ? [alternateStatements] : []), \"}\"])\n    return {...statement, alternate: {kind: /** @type {const} */ (\"Block\"), location: this.location(alternateStatements ?? node),\n      statements: this.statements(alternateStatements)}}\n  }\n\n  /**\n   * Converts one function body.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Function body.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n   */\n  block(node) {\n    const parts = this.parts(node)\n    const statements = parts[1]?.type == \"statements\" ? parts[1] : undefined\n\n    if (node.type != \"function_body\") this.fail(node, \"function body shape\")\n    this.shape(node, [\"{\", ...(statements ? [statements] : []), \"}\"])\n    return {kind: /** @type {const} */ (\"Block\"), location: this.location(node), statements: this.statements(statements)}\n  }\n\n  /**\n   * Converts one exact underscore-labeled parameter.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Parameter node.\n   * @returns {import(\"../semantic/types.js\").Parameter} Semantic parameter.\n   */\n  parameter(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"parameter\" || parts.length != 4 || parts[0].text != \"_\" || parts[0].type != \"simple_identifier\" ||\n      parts[1].type != \"simple_identifier\" || parts[2].text != \":\") this.fail(node, \"parameter shape\")\n    this.shape(node, [parts[0], parts[1], \":\", parts[3]])\n    const name = this.identifier(parts[1])\n\n    return withParserRanges({kind: /** @type {const} */ (\"Parameter\"), location: this.location(node), name, type: this.type(parts[3])}, {\n      name: this.location(parts[1])\n    })\n  }\n\n  /**\n   * Converts one synchronous top-level scalar function.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Function node.\n   * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n   */\n  function(node) {\n    const parts = this.parts(node)\n    const nameNode = node.childForFieldName(\"name\")\n    const body = node.childForFieldName(\"body\")\n    const parameters = parts.filter((part) => part.type == \"parameter\")\n\n    if (!nameNode || !body || node.type != \"function_declaration\") this.fail(node, \"function declaration shape\")\n    if (parameters.length != 2) this.fail(node, \"function parameter count other than two\")\n    if (!parts.some((part) => part.text == \"->\")) return missingType(\"swift\", \"Function return\", this.location(node))\n    if (parts.length != 10) this.fail(parts.find((part) => ![\"func\", \"(\", \",\", \")\", \"->\"].includes(part.text) &&\n      part.id != nameNode.id && part.id != body.id && !parameters.some((parameter) => parameter.id == part.id)) ?? node, \"function declaration shape\")\n    const returnType = parts[8]\n\n    this.shape(node, [\"func\", nameNode, \"(\", parameters[0], \",\", parameters[1], \")\", \"->\", returnType, body])\n    const name = this.identifier(nameNode)\n\n    return withParserRanges({\n      body: this.block(body),\n      kind: /** @type {const} */ (\"FunctionDeclaration\"),\n      location: this.location(node),\n      name,\n      parameters: parameters.map((parameter) => this.parameter(parameter)),\n      returnType: this.type(returnType)\n    }, {name: this.location(nameNode)})\n  }\n\n  /**\n   * Compares every child field and leaf token against target-only canonical support.\n   * @param {import(\"tree-sitter\").SyntaxNode} actual - Source support node.\n   * @param {import(\"tree-sitter\").SyntaxNode} expected - Canonical support node.\n   * @param {SwiftReader} canonical - Canonical source reader.\n   * @returns {void}\n   */\n  compareTree(actual, expected, canonical) {\n    if (actual.type != expected.type || actual.isNamed != expected.isNamed || actual.isExtra != expected.isExtra ||\n      actual.childCount != expected.childCount) this.fail(actual, \"modified Swift support node\")\n    if (!actual.childCount && actual.text != expected.text) this.fail(actual, \"modified Swift support token\")\n    for (let index = 0; index < actual.childCount; index += 1) {\n      const left = actual.child(index)\n      const right = expected.child(index)\n\n      if (!left || !right || actual.fieldNameForChild(index) != expected.fieldNameForChild(index)) {\n        this.fail(left ?? actual, \"modified Swift support field\")\n      }\n      this.compareTree(left, right, canonical)\n    }\n  }\n\n  /**\n   * Rejects ordinary Swift equality after shared type resolution identifies Strings.\n   * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated semantic module.\n   * @returns {void}\n   */\n  rejectNativeStringEquality(module) {\n    const pending = [module.entryPoint.body, ...module.functions.map((declaration) => declaration.body)]\n\n    while (pending.length) {\n      const block = pending.pop()\n\n      if (!block) throw new Error(\"Swift semantic traversal lost a pending block.\")\n      for (const statement of block.statements) {\n        if (statement.kind == \"IfStatement\") {\n          pending.push(statement.consequent)\n          if (statement.alternate) pending.push(statement.alternate)\n          this.rejectNativeStringEqualityExpression(statement.condition)\n        } else if (statement.kind == \"LocalDeclaration\") this.rejectNativeStringEqualityExpression(statement.initializer)\n        else if (statement.kind == \"AssignmentStatement\") this.rejectNativeStringEqualityExpression(statement.expression)\n        else if (statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\") {\n          this.rejectNativeStringEqualityExpression(statement.expression)\n        } else if (statement.kind == \"ReturnStatement\" && statement.expression) {\n          this.rejectNativeStringEqualityExpression(statement.expression)\n        }\n      }\n    }\n  }\n\n  /**\n   * Checks one validated expression without retaining parser state in public values.\n   * @param {import(\"../semantic/types.js\").Expression} root - Validated expression.\n   * @returns {void}\n   */\n  rejectNativeStringEqualityExpression(root) {\n    const pending = [root]\n\n    while (pending.length) {\n      const expression = pending.pop()\n\n      if (!expression) throw new Error(\"Swift semantic traversal lost a pending expression.\")\n      if (expression.kind == \"BinaryExpression\") {\n        const operator = this.nativeEqualityOperators.get(expression)\n\n        if (operator && [\"StringEqual\", \"StringNotEqual\"].includes(expression.operation)) {\n          this.fail(operator, \"ordinary Swift String equality\")\n        }\n        pending.push(expression.left, expression.right)\n      } else if (expression.kind == \"UnaryExpression\") pending.push(expression.operand)\n      else if (expression.kind == \"CallExpression\") pending.push(...expression.arguments)\n    }\n  }\n\n  /**\n   * Converts the complete source file with declarations before top-level entry statements.\n   * @param {import(\"tree-sitter\").SyntaxNode} root - Source root.\n   * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n   */\n  module(root) {\n    this.validateTree(root)\n    if (root.type != \"source_file\") this.fail(root, \"source file root\")\n    const parts = this.parts(root)\n    const canonical = new SwiftReader(this.filename, swiftRuntime)\n    const support = canonical.parts(parser.parse(swiftRuntime).rootNode)\n    let supportIndex = 0\n\n    while (supportIndex < parts.length && supportIndex < support.length) {\n      const node = parts[supportIndex]\n      const name = node.type == \"function_declaration\" ? node.childForFieldName(\"name\") : undefined\n      const expectedName = support[supportIndex].childForFieldName(\"name\")\n\n      if (!name || !expectedName || name.text != expectedName.text) break\n      this.compareTree(node, support[supportIndex], canonical)\n      if (helperOperations.has(name.text)) this.helpers.add(name.text)\n      else if (name.text == \"semantifold_keep_mutable\") this.mutableMarker = true\n      supportIndex += 1\n    }\n    if (supportIndex > 0 && supportIndex != support.length) this.fail(parts[supportIndex - 1], \"complete Swift support required\")\n    const semanticParts = parts.slice(supportIndex)\n    const firstEntry = semanticParts.findIndex((node) => node.type != \"function_declaration\")\n    const split = firstEntry < 0 ? semanticParts.length : firstEntry\n    const declarations = semanticParts.slice(0, split)\n    const entries = semanticParts.slice(split)\n\n    if (!declarations.length) this.fail(root, \"top-level semantic function required\")\n    const laterFunction = entries.find((node) => node.type == \"function_declaration\")\n    const unsupportedEntry = entries.find((node) => ![\"assignment\", \"call_expression\", \"control_transfer_statement\", \"if_statement\",\n      \"property_declaration\", \"function_declaration\"].includes(node.type))\n\n    if (unsupportedEntry) this.fail(unsupportedEntry)\n    if (laterFunction) this.fail(laterFunction, \"function declaration after entry statement\")\n    if (!entries.length) this.fail(root, \"top-level entry/print shell required\")\n    const module = {\n      entryPoint: {body: {kind: /** @type {const} */ (\"Block\"), location: this.location(root),\n        statements: this.statementList(entries)}, kind: /** @type {const} */ (\"EntryPoint\"), location: this.location(root)},\n      functions: declarations.map((declaration) => this.function(declaration)),\n      kind: /** @type {const} */ (\"Module\"),\n      location: this.location(root)\n    }\n\n    validateParsedModule(module, \"swift\")\n    this.rejectNativeStringEquality(module)\n    return module\n  }\n}\n\n/**\n * Parses the strict Task 022 Swift profile through the qualified grammar.\n * @param {{filename: string, source: string}} input - Exact source request.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parseSwift({filename, source}) {\n  if (!hasOnlyUnicodeScalars(source)) {\n    const offset = firstLoneSurrogateOffset(source)\n\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\",\n      language: \"swift\",\n      location: locationFromOffsets(filename, source, offset, offset + 1),\n      message: \"Swift source contains an invalid lone UTF-16 surrogate.\"\n    })\n  }\n  let tree\n\n  try {\n    tree = parser.parse(source)\n  } catch (error) {\n    throw new SemantifoldDiagnostic({\n      cause: error instanceof Error ? error : undefined,\n      code: \"PARSE_ERROR\",\n      language: \"swift\",\n      location: moduleLocation(filename, source),\n      message: \"The qualified Swift parser could not produce a complete CST.\"\n    })\n  }\n  return new SwiftReader(filename, source).module(tree.rootNode)\n}\n"]}