semantifold 0.3.0 → 0.5.0

package/build/src/frontends/kotlin.js

@@ -0,0 +1,685 @@
+// @ts-check
+import Parser from "tree-sitter";
+import KotlinLanguage from "tree-sitter-kotlin";
+import { isKotlinIdentifier } from "../backends/identifiers.js";
+import { kotlinRuntime } from "../backends/kotlin-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} */(KotlinLanguage)));
+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(["||"])]
+]);
+/** @type {Map<string, import("../semantic/operators.js").AdaptedOperation>} */
+const helperOperations = new Map([
+    ["semantifold_integer_add", "Add"], ["semantifold_integer_subtract", "Subtract"],
+    ["semantifold_integer_multiply", "Multiply"], ["semantifold_integer_negate", "Negate"]
+]);
+const commentTypes = new Set(["line_comment", "multiline_comment"]);
+/**
+ * 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 Kotlin CST shapes without retaining parser handles. */
+class KotlinReader {
+    /**
+     * Creates a reader over one parser-owned Kotlin source.
+     * @param {string} filename - Original filename.
+     * @param {string} source - Complete source.
+     */
+    constructor(filename, source) {
+        this.filename = filename;
+        this.source = source;
+        this.runtime = false;
+    }
+    /**
+     * 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("kotlin", 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("Kotlin 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: "kotlin",
+                    location: this.location(node),
+                    message: `Tree-sitter exposed recovery at '${node.type}'.`
+                });
+            }
+            if (["annotation", "file_annotation", "shebang_line"].includes(node.type))
+                this.fail(node, node.type);
+            if (commentTypes.has(node.type) && /(?:language|api|jvm)[-_ ]version/iu.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) => !commentTypes.has(child.type));
+    }
+    /**
+     * 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`);
+        }
+    }
+    /**
+     * 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];
+    }
+    /**
+     * Validates one Kotlin identifier in the portable source profile.
+     * @param {import("tree-sitter").SyntaxNode} node - Identifier token.
+     * @param {boolean} [allowMain] - Whether the fixed main scaffold is expected.
+     * @param {boolean} [allowPrint] - Whether the fixed print scaffold is expected.
+     * @returns {string} Accepted spelling.
+     */
+    identifier(node, allowMain = false, allowPrint = false) {
+        const name = node.text;
+        if (node.type != "simple_identifier" || !(allowMain && name == "main") && !(allowPrint && name == "println") &&
+            (!isKotlinIdentifier(name) || name.normalize("NFC") != name))
+            this.fail(node, "reserved or unsupported identifier");
+        return name;
+    }
+    /**
+     * Converts exactly Long, Boolean, 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("kotlin", parts[0].text, this.location(parts[0]));
+        if (!type)
+            this.fail(parts[0], `unsupported scalar type '${parts[0].text}'`);
+        return type;
+    }
+    /**
+     * Decodes an ordinary noninterpolated Kotlin string.
+     * @param {import("tree-sitter").SyntaxNode} node - String literal node.
+     * @returns {string} Decoded Unicode scalar string.
+     */
+    string(node) {
+        const parts = this.parts(node);
+        if (node.type != "string_literal" || parts.some((part) => part.type != "string_content") ||
+            !node.text.startsWith('"') || !node.text.endsWith('"'))
+            this.fail(node, "ordinary noninterpolated string literal required");
+        this.shape(node, parts);
+        let value = "";
+        const simpleEscapes = new Map([
+            ["t", "\t"], ["b", "\b"], ["n", "\n"], ["r", "\r"], ["'", "'"], ['"', '"'], ["\\", "\\"], ["$", "$"]
+        ]);
+        for (let index = 1; index < node.text.length - 1; index += 1) {
+            const character = node.text[index];
+            if (character != "\\") {
+                if (character == "\n" || character == "\r" || character == '"')
+                    this.fail(node, "invalid string content");
+                value += character;
+                continue;
+            }
+            const escaped = node.text[++index];
+            if (simpleEscapes.has(escaped))
+                value += simpleEscapes.get(escaped);
+            else if (escaped == "u") {
+                const hexadecimal = node.text.slice(index + 1, index + 5);
+                if (!/^[0-9A-Fa-f]{4}$/u.test(hexadecimal))
+                    this.fail(node, "unsupported string escape");
+                value += String.fromCharCode(Number.parseInt(hexadecimal, 16));
+                index += 4;
+            }
+            else
+                this.fail(node, "unsupported string escape");
+        }
+        if (!hasOnlyUnicodeScalars(value))
+            this.fail(node, "invalid Unicode string literal");
+        return value;
+    }
+    /**
+     * Extracts exact unnamed call arguments.
+     * @param {import("tree-sitter").SyntaxNode} suffix - Call suffix node.
+     * @returns {import("tree-sitter").SyntaxNode[]} Argument expression 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);
+        this.shape(list, ["(", ...arguments_.flatMap((argument, index) => index ? [",", argument] : [argument]), ")"]);
+        return arguments_.map((argument) => {
+            const argumentParts = this.parts(argument);
+            if (argument.type != "value_argument" || argumentParts.length != 1)
+                this.fail(argument, "unnamed argument required");
+            this.shape(argument, [argumentParts[0]]);
+            return argumentParts[0];
+        });
+    }
+    /**
+     * Converts a direct semantic or generated-helper call.
+     * @param {import("tree-sitter").SyntaxNode} node - Call expression node.
+     * @returns {import("../semantic/types.js").Expression} Semantic expression.
+     */
+    call(node) {
+        const parts = this.parts(node);
+        if (node.type != "call_expression" || parts.length != 2 || parts[0].type != "simple_identifier")
+            this.fail(node, "direct call shape");
+        this.shape(node, [parts[0], parts[1]]);
+        const argumentNodes = this.arguments(parts[1]);
+        const name = parts[0].text;
+        const helper = this.runtime ? helperOperations.get(name) : undefined;
+        const location = this.location(node);
+        if (helper) {
+            const count = helper == "Negate" ? 1 : 2;
+            if (argumentNodes.length != count)
+                this.fail(node, "Kotlin checked-integer helper shape");
+            if (helper == "Negate") {
+                return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+                    kind: /** @type {const} */ ("UnaryExpression"), location, operand: this.expression(argumentNodes[0])
+                }, { operator: this.location(parts[0]) }), helper)));
+            }
+            return /** @type {import("../semantic/types.js").Expression} */ (withAdaptedOperation(withParserRanges({
+                kind: /** @type {const} */ ("BinaryExpression"), left: this.expression(argumentNodes[0]), location, right: this.expression(argumentNodes[1])
+            }, { operator: this.location(parts[0]) }), helper));
+        }
+        const semanticName = this.identifier(parts[0]);
+        if (argumentNodes.length != 2)
+            this.fail(parts[1], "semantic call argument count");
+        return withParserRanges({
+            arguments: argumentNodes.map((argument) => this.expression(argument)), callee: semanticName,
+            kind: /** @type {const} */ ("CallExpression"), location
+        }, { callee: this.location(parts[0]) });
+    }
+    /**
+     * 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" || node.type == "long_literal") {
+            const literal = node.type == "long_literal" ? this.parts(node)[0] : node;
+            if (node.type == "long_literal")
+                this.shape(node, [literal, "L"]);
+            if (!literal || literal.type != "integer_literal" || !/^(?:0|[1-9][0-9]*)$/u.test(literal.text) ||
+                node.type == "long_literal" && !/L$/u.test(node.text))
+                this.fail(node, "noncanonical integer literal");
+            const value = Number(BigInt(literal.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 == "string_literal") {
+            return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: this.string(node) }, { literal: location });
+        }
+        if (node.type == "parenthesized_expression") {
+            const parts = this.parts(node);
+            if (parts.length != 3)
+                this.fail(node, "parenthesized expression shape");
+            this.shape(node, ["(", parts[1], ")"]);
+            return this.expression(parts[1]);
+        }
+        if (node.type == "prefix_expression") {
+            const parts = this.parts(node);
+            if (parts.length != 2 || !["-", "!"].includes(parts[0].text))
+                this.fail(node, "unary operator");
+            this.shape(node, [parts[0].text, parts[1]]);
+            return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+                kind: /** @type {const} */ ("UnaryExpression"), location, operand: this.expression(parts[1])
+            }, { operator: this.location(parts[0]) }), parts[0].text == "-" ? "Negate" : "Not")));
+        }
+        if (binaryNodeOperators.has(node.type))
+            return this.binary(node);
+        if (node.type == "call_expression")
+            return this.call(node);
+        return this.fail(node);
+    }
+    /**
+     * Converts one binary expression.
+     * @param {import("tree-sitter").SyntaxNode} node - Binary expression node.
+     * @returns {import("../semantic/types.js").Expression} Semantic expression.
+     */
+    binary(node) {
+        const parts = this.parts(node);
+        const accepted = binaryNodeOperators.get(node.type);
+        if (parts.length != 3)
+            this.fail(node, `${node.type} child shape`);
+        this.shape(node, [parts[0], parts[1], parts[2]]);
+        const operation = binaryOperations.get(parts[1].text);
+        if (!accepted?.has(parts[1].text) || !operation)
+            this.fail(parts[1], "unsupported binary operator");
+        return /** @type {import("../semantic/types.js").Expression} */ (withAdaptedOperation(withParserRanges({
+            kind: /** @type {const} */ ("BinaryExpression"), left: this.expression(parts[0]), location: this.location(node), right: this.expression(parts[2])
+        }, { operator: this.location(parts[1]) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (operation)));
+    }
+    /**
+     * Converts one explicitly typed local declaration.
+     * @param {import("tree-sitter").SyntaxNode} node - Property declaration node.
+     * @returns {import("../semantic/types.js").LocalDeclaration} Semantic declaration.
+     */
+    local(node) {
+        const parts = this.parts(node);
+        const location = this.location(node);
+        if (node.type != "property_declaration" || parts.length != 4 || parts[0].type != "binding_pattern_kind" ||
+            parts[1].type != "variable_declaration" || parts[2].text != "=")
+            this.fail(node, "local declaration shape");
+        const bindingParts = this.parts(parts[0]);
+        const variableParts = this.parts(parts[1]);
+        if (bindingParts.length != 1 || !["val", "var"].includes(bindingParts[0].text))
+            this.fail(parts[0], "local binding kind");
+        if (variableParts.length == 1)
+            return missingType("kotlin", "Local", location);
+        if (variableParts.length != 3 || variableParts[0].type != "simple_identifier" || variableParts[1].text != ":") {
+            this.fail(parts[1], "local declaration shape");
+        }
+        this.shape(parts[0], [bindingParts[0].text]);
+        this.shape(parts[1], [variableParts[0], ":", variableParts[2]]);
+        this.shape(node, [parts[0], parts[1], "=", parts[3]]);
+        const name = this.identifier(variableParts[0]);
+        return withParserRanges({
+            initializer: this.expression(parts[3]), kind: /** @type {const} */ ("LocalDeclaration"), location,
+            mutable: bindingParts[0].text == "var", name, type: this.type(variableParts[2])
+        }, { name: this.location(variableParts[0]), operator: this.location(parts[2]) });
+    }
+    /**
+     * Converts one plain local assignment.
+     * @param {import("tree-sitter").SyntaxNode} node - Assignment node.
+     * @returns {import("../semantic/types.js").AssignmentStatement} Semantic assignment.
+     */
+    assignment(node) {
+        const parts = this.parts(node);
+        if (node.type != "assignment" || parts.length != 3 || parts[0].type != "directly_assignable_expression" || parts[1].text != "=") {
+            this.fail(node, "assignment shape");
+        }
+        const targetParts = this.parts(parts[0]);
+        if (targetParts.length != 1 || targetParts[0].type != "simple_identifier")
+            this.fail(parts[0], "assignment target shape");
+        this.shape(parts[0], [targetParts[0]]);
+        this.shape(node, [parts[0], "=", parts[2]]);
+        const name = this.identifier(targetParts[0]);
+        const targetLocation = this.location(targetParts[0]);
+        return withParserRanges({
+            expression: this.expression(parts[2]), kind: /** @type {const} */ ("AssignmentStatement"), location: this.location(node),
+            target: withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: targetLocation, name }, { name: targetLocation })
+        }, { operator: this.location(parts[1]) });
+    }
+    /**
+     * Converts the exact println entry scaffold.
+     * @param {import("tree-sitter").SyntaxNode} node - Call node.
+     * @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], false, true) != "println")
+            this.fail(node, "exact println call required");
+        const arguments_ = this.arguments(parts[1]);
+        if (arguments_.length != 1)
+            this.fail(parts[1], "println 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_expression")
+            return this.conditional(node);
+        if (node.type == "call_expression")
+            return this.print(node);
+        if (node.type == "jump_expression") {
+            const parts = this.parts(node);
+            if (parts.length != 2 || parts[0].text != "return")
+                this.fail(node, "return expression shape");
+            this.shape(node, ["return", parts[1]]);
+            return { expression: this.expression(parts[1]), kind: /** @type {const} */ ("ReturnStatement"), location: this.location(node) };
+        }
+        return this.fail(node);
+    }
+    /**
+     * Converts an optional parser statement list.
+     * @param {import("tree-sitter").SyntaxNode | undefined} node - Statement-list node.
+     * @returns {import("../semantic/types.js").Statement[]} Semantic statements.
+     */
+    statements(node) {
+        if (!node)
+            return [];
+        if (node.type != "statements")
+            this.fail(node, "statement list shape");
+        return this.parts(node).map((statement) => this.statement(statement));
+    }
+    /**
+     * Converts one braced conditional body.
+     * @param {import("tree-sitter").SyntaxNode} node - Control body node.
+     * @returns {import("../semantic/types.js").Block} Semantic block.
+     */
+    controlBody(node) {
+        const parts = this.parts(node);
+        const statements = parts[1]?.type == "statements" ? parts[1] : undefined;
+        if (node.type != "control_structure_body")
+            this.fail(node, "conditional block shape");
+        this.shape(node, ["{", ...(statements ? [statements] : []), "}"]);
+        return { kind: /** @type {const} */ ("Block"), location: this.location(node), statements: this.statements(statements) };
+    }
+    /**
+     * Converts one strict Boolean conditional.
+     * @param {import("tree-sitter").SyntaxNode} node - If expression node.
+     * @returns {import("../semantic/types.js").IfStatement} Semantic conditional.
+     */
+    conditional(node) {
+        const parts = this.parts(node);
+        const condition = this.field(node, "condition");
+        const consequence = this.field(node, "consequence");
+        const base = ["if", "(", condition, ")", consequence];
+        if (node.type != "if_expression" || consequence.type != "control_structure_body")
+            this.fail(node, "if expression shape");
+        const statement = /** @type {import("../semantic/types.js").IfStatement} */ ({
+            condition: this.expression(condition), consequent: this.controlBody(consequence), kind: /** @type {const} */ ("IfStatement"),
+            location: this.location(node)
+        });
+        if (parts.length == base.length) {
+            this.shape(node, base);
+            return statement;
+        }
+        const alternative = this.field(node, "alternative");
+        this.shape(node, [...base, "else", alternative]);
+        if (alternative.type != "control_structure_body")
+            this.fail(alternative, "if alternate shape");
+        const alternativeParts = this.parts(alternative);
+        if (alternativeParts.length == 1 && alternativeParts[0].type == "if_expression") {
+            this.shape(alternative, [alternativeParts[0]]);
+            return { ...statement, alternate: { kind: /** @type {const} */ ("Block"), location: this.location(alternative),
+                    statements: [this.conditional(alternativeParts[0])] } };
+        }
+        return { ...statement, alternate: this.controlBody(alternative) };
+    }
+    /**
+     * Converts one exact braced block.
+     * @param {import("tree-sitter").SyntaxNode} node - Block node.
+     * @param {"function_body" | "control_structure_body"} type - Required parser node type.
+     * @returns {import("../semantic/types.js").Block} Semantic block.
+     */
+    block(node, type = "function_body") {
+        const parts = this.parts(node);
+        const statements = parts[1]?.type == "statements" ? parts[1] : undefined;
+        if (node.type != type)
+            this.fail(node, `${type} shape`);
+        this.shape(node, ["{", ...(statements ? [statements] : []), "}"]);
+        return { kind: /** @type {const} */ ("Block"), location: this.location(node), statements: this.statements(statements) };
+    }
+    /**
+     * Converts one explicitly typed 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 != 3 || parts[0].type != "simple_identifier" || parts[1].text != ":") {
+            this.fail(node, "parameter shape");
+        }
+        this.shape(node, [parts[0], ":", parts[2]]);
+        const name = this.identifier(parts[0]);
+        return withParserRanges({ kind: /** @type {const} */ ("Parameter"), location: this.location(node), name, type: this.type(parts[2]) }, {
+            name: this.location(parts[0])
+        });
+    }
+    /**
+     * Converts one supported top-level function.
+     * @param {import("tree-sitter").SyntaxNode} node - Function declaration node.
+     * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+     */
+    function(node) {
+        const parts = this.parts(node);
+        if (node.type != "function_declaration" || parts.length < 4 || parts[0].text != "fun" || parts[1].type != "simple_identifier" ||
+            parts[2].type != "function_value_parameters" || parts.at(-1)?.type != "function_body")
+            this.fail(node, "function declaration shape");
+        if (!parts.some((part) => part.text == ":"))
+            return missingType("kotlin", "Function return", this.location(node));
+        if (parts.length != 6 || parts[3].text != ":")
+            this.fail(node, "function declaration shape");
+        this.shape(node, ["fun", parts[1], parts[2], ":", parts[4], parts[5]]);
+        const parameterParts = this.parts(parts[2]);
+        const parameters = parameterParts.filter((part) => part.type == "parameter");
+        if (parameters.length != 2)
+            this.fail(parts[2], "function parameter count other than two");
+        this.shape(parts[2], ["(", parameters[0], ",", parameters[1], ")"]);
+        const name = this.identifier(parts[1]);
+        return withParserRanges({
+            body: this.block(parts[5]), kind: /** @type {const} */ ("FunctionDeclaration"), location: this.location(node), name,
+            parameters: parameters.map((parameter) => this.parameter(parameter)), returnType: this.type(parts[4])
+        }, { name: this.location(parts[1]) });
+    }
+    /**
+     * Converts the exact final main function.
+     * @param {import("tree-sitter").SyntaxNode} node - Main declaration node.
+     * @returns {import("../semantic/types.js").EntryPoint} Semantic entry point.
+     */
+    main(node) {
+        const parts = this.parts(node);
+        if (node.type != "function_declaration" || parts.length != 4 || parts[0].text != "fun" ||
+            this.identifier(parts[1], true) != "main" || parts[2].type != "function_value_parameters" || parts[3].type != "function_body") {
+            this.fail(node, "exact main declaration required");
+        }
+        this.shape(parts[2], ["(", ")"]);
+        this.shape(node, ["fun", parts[1], parts[2], parts[3]]);
+        return { body: this.block(parts[3]), kind: /** @type {const} */ ("EntryPoint"), location: this.location(node) };
+    }
+    /**
+     * Compares source support with the canonical generated helper CST.
+     * @param {import("tree-sitter").SyntaxNode} actual - Source node.
+     * @param {import("tree-sitter").SyntaxNode} expected - Canonical support node.
+     * @returns {void}
+     */
+    compareTree(actual, expected) {
+        if (actual.type != expected.type || actual.isNamed != expected.isNamed || actual.isExtra != expected.isExtra ||
+            actual.childCount != expected.childCount)
+            this.fail(actual, "modified Kotlin support node");
+        if (!actual.childCount && actual.text != expected.text)
+            this.fail(actual, "modified Kotlin 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 Kotlin support field");
+            }
+            this.compareTree(left, right);
+        }
+    }
+    /**
+     * Converts and validates one complete Kotlin source file.
+     * @param {import("tree-sitter").SyntaxNode} root - Source file 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 supportTree = parser.parse(kotlinRuntime);
+        const support = this.parts(supportTree.rootNode);
+        let supportIndex = 0;
+        while (supportIndex < parts.length && supportIndex < support.length && parts[supportIndex].type == support[supportIndex].type) {
+            this.compareTree(parts[supportIndex], support[supportIndex]);
+            supportIndex += 1;
+        }
+        if (supportIndex > 0 && supportIndex != support.length)
+            this.fail(parts[supportIndex - 1], "complete Kotlin support required");
+        this.runtime = supportIndex == support.length;
+        const semanticParts = parts.slice(supportIndex);
+        const mainIndex = semanticParts.findIndex((node) => node.type == "function_declaration" && this.parts(node)[1]?.text == "main");
+        if (mainIndex < 0)
+            this.fail(root, "source file without main");
+        if (mainIndex == 0)
+            this.fail(semanticParts[0], "top-level semantic function required");
+        if (mainIndex != semanticParts.length - 1)
+            this.fail(semanticParts[mainIndex + 1], "declaration after main");
+        const declarations = semanticParts.slice(0, mainIndex);
+        for (const declaration of declarations) {
+            if (declaration.type != "function_declaration")
+                this.fail(declaration);
+        }
+        const module = {
+            entryPoint: this.main(semanticParts[mainIndex]), functions: declarations.map((declaration) => this.function(declaration)),
+            kind: /** @type {const} */ ("Module"), location: this.location(root)
+        };
+        validateParsedModule(module, "kotlin");
+        return module;
+    }
+}
+/**
+ * Parses the strict Task 023 Kotlin/JVM profile through the qualified grammar.
+ * @param {{filename: string, source: string}} input - Exact source request.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parseKotlin({ filename, source }) {
+    if (!hasOnlyUnicodeScalars(source)) {
+        const offset = firstLoneSurrogateOffset(source);
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR", language: "kotlin", location: locationFromOffsets(filename, source, offset, offset + 1),
+            message: "Kotlin 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: "kotlin",
+            location: moduleLocation(filename, source), message: "The qualified Kotlin parser could not produce a complete CST."
+        });
+    }
+    return new KotlinReader(filename, source).module(tree.rootNode);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kotlin.js","sourceRoot":"","sources":["../../../src/frontends/kotlin.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Parser from \"tree-sitter\"\nimport KotlinLanguage from \"tree-sitter-kotlin\"\nimport {isKotlinIdentifier} from \"../backends/identifiers.js\"\nimport {kotlinRuntime} from \"../backends/kotlin-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} */ (KotlinLanguage)))\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])\n/** @type {Map<string, import(\"../semantic/operators.js\").AdaptedOperation>} */\nconst helperOperations = new Map([\n  [\"semantifold_integer_add\", \"Add\"], [\"semantifold_integer_subtract\", \"Subtract\"],\n  [\"semantifold_integer_multiply\", \"Multiply\"], [\"semantifold_integer_negate\", \"Negate\"]\n])\nconst commentTypes = new Set([\"line_comment\", \"multiline_comment\"])\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 Kotlin CST shapes without retaining parser handles. */\nclass KotlinReader {\n  /**\n   * Creates a reader over one parser-owned Kotlin 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    this.runtime = false\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(\"kotlin\", 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(\"Kotlin 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: \"kotlin\",\n          location: this.location(node),\n          message: `Tree-sitter exposed recovery at '${node.type}'.`\n        })\n      }\n      if ([\"annotation\", \"file_annotation\", \"shebang_line\"].includes(node.type)) this.fail(node, node.type)\n      if (commentTypes.has(node.type) && /(?:language|api|jvm)[-_ ]version/iu.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) => !commentTypes.has(child.type))\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   * 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   * Validates one Kotlin identifier in the portable source profile.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Identifier token.\n   * @param {boolean} [allowMain] - Whether the fixed main scaffold is expected.\n   * @param {boolean} [allowPrint] - Whether the fixed print scaffold is expected.\n   * @returns {string} Accepted spelling.\n   */\n  identifier(node, allowMain = false, allowPrint = false) {\n    const name = node.text\n\n    if (node.type != \"simple_identifier\" || !(allowMain && name == \"main\") && !(allowPrint && name == \"println\") &&\n      (!isKotlinIdentifier(name) || name.normalize(\"NFC\") != name)) this.fail(node, \"reserved or unsupported identifier\")\n    return name\n  }\n\n  /**\n   * Converts exactly Long, Boolean, 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(\"kotlin\", 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   * Decodes an ordinary noninterpolated Kotlin string.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - String literal node.\n   * @returns {string} Decoded Unicode scalar string.\n   */\n  string(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"string_literal\" || parts.some((part) => part.type != \"string_content\") ||\n      !node.text.startsWith('\"') || !node.text.endsWith('\"')) this.fail(node, \"ordinary noninterpolated string literal required\")\n    this.shape(node, parts)\n    let value = \"\"\n    const simpleEscapes = new Map([\n      [\"t\", \"\\t\"], [\"b\", \"\\b\"], [\"n\", \"\\n\"], [\"r\", \"\\r\"], [\"'\", \"'\"], ['\"', '\"'], [\"\\\\\", \"\\\\\"], [\"$\", \"$\"]\n    ])\n\n    for (let index = 1; index < node.text.length - 1; index += 1) {\n      const character = node.text[index]\n\n      if (character != \"\\\\\") {\n        if (character == \"\\n\" || character == \"\\r\" || character == '\"') this.fail(node, \"invalid string content\")\n        value += character\n        continue\n      }\n      const escaped = node.text[++index]\n\n      if (simpleEscapes.has(escaped)) value += simpleEscapes.get(escaped)\n      else if (escaped == \"u\") {\n        const hexadecimal = node.text.slice(index + 1, index + 5)\n\n        if (!/^[0-9A-Fa-f]{4}$/u.test(hexadecimal)) this.fail(node, \"unsupported string escape\")\n        value += String.fromCharCode(Number.parseInt(hexadecimal, 16))\n        index += 4\n      } else this.fail(node, \"unsupported string escape\")\n    }\n    if (!hasOnlyUnicodeScalars(value)) this.fail(node, \"invalid Unicode string literal\")\n    return value\n  }\n\n  /**\n   * Extracts exact unnamed call arguments.\n   * @param {import(\"tree-sitter\").SyntaxNode} suffix - Call suffix node.\n   * @returns {import(\"tree-sitter\").SyntaxNode[]} Argument expression 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\n    this.shape(list, [\"(\", ...arguments_.flatMap((argument, index) => index ? [\",\", argument] : [argument]), \")\"])\n    return arguments_.map((argument) => {\n      const argumentParts = this.parts(argument)\n\n      if (argument.type != \"value_argument\" || argumentParts.length != 1) this.fail(argument, \"unnamed argument required\")\n      this.shape(argument, [argumentParts[0]])\n      return argumentParts[0]\n    })\n  }\n\n  /**\n   * Converts a direct semantic or generated-helper call.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Call expression node.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n   */\n  call(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"call_expression\" || parts.length != 2 || parts[0].type != \"simple_identifier\") this.fail(node, \"direct call shape\")\n    this.shape(node, [parts[0], parts[1]])\n    const argumentNodes = this.arguments(parts[1])\n    const name = parts[0].text\n    const helper = this.runtime ? helperOperations.get(name) : undefined\n    const location = this.location(node)\n\n    if (helper) {\n      const count = helper == \"Negate\" ? 1 : 2\n\n      if (argumentNodes.length != count) this.fail(node, \"Kotlin checked-integer helper shape\")\n      if (helper == \"Negate\") {\n        return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n          kind: /** @type {const} */ (\"UnaryExpression\"), location, operand: this.expression(argumentNodes[0])\n        }, {operator: this.location(parts[0])}), helper)))\n      }\n      return /** @type {import(\"../semantic/types.js\").Expression} */ (withAdaptedOperation(withParserRanges({\n        kind: /** @type {const} */ (\"BinaryExpression\"), left: this.expression(argumentNodes[0]), location, right: this.expression(argumentNodes[1])\n      }, {operator: this.location(parts[0])}), helper))\n    }\n    const semanticName = this.identifier(parts[0])\n\n    if (argumentNodes.length != 2) this.fail(parts[1], \"semantic call argument count\")\n    return withParserRanges({\n      arguments: argumentNodes.map((argument) => this.expression(argument)), callee: semanticName,\n      kind: /** @type {const} */ (\"CallExpression\"), location\n    }, {callee: this.location(parts[0])})\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\" || node.type == \"long_literal\") {\n      const literal = node.type == \"long_literal\" ? this.parts(node)[0] : node\n\n      if (node.type == \"long_literal\") this.shape(node, [literal, \"L\"])\n      if (!literal || literal.type != \"integer_literal\" || !/^(?:0|[1-9][0-9]*)$/u.test(literal.text) ||\n        node.type == \"long_literal\" && !/L$/u.test(node.text)) this.fail(node, \"noncanonical integer literal\")\n      const value = Number(BigInt(literal.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 == \"string_literal\") {\n      return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: this.string(node)}, {literal: location})\n    }\n    if (node.type == \"parenthesized_expression\") {\n      const parts = this.parts(node)\n\n      if (parts.length != 3) this.fail(node, \"parenthesized expression shape\")\n      this.shape(node, [\"(\", parts[1], \")\"])\n      return this.expression(parts[1])\n    }\n    if (node.type == \"prefix_expression\") {\n      const parts = this.parts(node)\n\n      if (parts.length != 2 || ![\"-\", \"!\"].includes(parts[0].text)) this.fail(node, \"unary operator\")\n      this.shape(node, [parts[0].text, parts[1]])\n      return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n        kind: /** @type {const} */ (\"UnaryExpression\"), location, operand: this.expression(parts[1])\n      }, {operator: this.location(parts[0])}), parts[0].text == \"-\" ? \"Negate\" : \"Not\")))\n    }\n    if (binaryNodeOperators.has(node.type)) return this.binary(node)\n    if (node.type == \"call_expression\") return this.call(node)\n    return this.fail(node)\n  }\n\n  /**\n   * Converts one binary expression.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Binary expression node.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n   */\n  binary(node) {\n    const parts = this.parts(node)\n    const accepted = binaryNodeOperators.get(node.type)\n\n    if (parts.length != 3) this.fail(node, `${node.type} child shape`)\n    this.shape(node, [parts[0], parts[1], parts[2]])\n    const operation = binaryOperations.get(parts[1].text)\n\n    if (!accepted?.has(parts[1].text) || !operation) this.fail(parts[1], \"unsupported binary operator\")\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (withAdaptedOperation(withParserRanges({\n      kind: /** @type {const} */ (\"BinaryExpression\"), left: this.expression(parts[0]), location: this.location(node), right: this.expression(parts[2])\n    }, {operator: this.location(parts[1])}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (operation)))\n  }\n\n  /**\n   * Converts one explicitly typed local declaration.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Property declaration node.\n   * @returns {import(\"../semantic/types.js\").LocalDeclaration} Semantic declaration.\n   */\n  local(node) {\n    const parts = this.parts(node)\n    const location = this.location(node)\n\n    if (node.type != \"property_declaration\" || parts.length != 4 || parts[0].type != \"binding_pattern_kind\" ||\n      parts[1].type != \"variable_declaration\" || parts[2].text != \"=\") this.fail(node, \"local declaration shape\")\n    const bindingParts = this.parts(parts[0])\n    const variableParts = this.parts(parts[1])\n\n    if (bindingParts.length != 1 || ![\"val\", \"var\"].includes(bindingParts[0].text)) this.fail(parts[0], \"local binding kind\")\n    if (variableParts.length == 1) return missingType(\"kotlin\", \"Local\", location)\n    if (variableParts.length != 3 || variableParts[0].type != \"simple_identifier\" || variableParts[1].text != \":\") {\n      this.fail(parts[1], \"local declaration shape\")\n    }\n    this.shape(parts[0], [bindingParts[0].text])\n    this.shape(parts[1], [variableParts[0], \":\", variableParts[2]])\n    this.shape(node, [parts[0], parts[1], \"=\", parts[3]])\n    const name = this.identifier(variableParts[0])\n\n    return withParserRanges({\n      initializer: this.expression(parts[3]), kind: /** @type {const} */ (\"LocalDeclaration\"), location,\n      mutable: bindingParts[0].text == \"var\", name, type: this.type(variableParts[2])\n    }, {name: this.location(variableParts[0]), operator: this.location(parts[2])})\n  }\n\n  /**\n   * Converts one plain local 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 parts = this.parts(node)\n\n    if (node.type != \"assignment\" || parts.length != 3 || parts[0].type != \"directly_assignable_expression\" || parts[1].text != \"=\") {\n      this.fail(node, \"assignment shape\")\n    }\n    const targetParts = this.parts(parts[0])\n\n    if (targetParts.length != 1 || targetParts[0].type != \"simple_identifier\") this.fail(parts[0], \"assignment target shape\")\n    this.shape(parts[0], [targetParts[0]])\n    this.shape(node, [parts[0], \"=\", parts[2]])\n    const name = this.identifier(targetParts[0])\n    const targetLocation = this.location(targetParts[0])\n\n    return withParserRanges({\n      expression: this.expression(parts[2]), kind: /** @type {const} */ (\"AssignmentStatement\"), location: this.location(node),\n      target: withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: targetLocation, name}, {name: targetLocation})\n    }, {operator: this.location(parts[1])})\n  }\n\n  /**\n   * Converts the exact println entry scaffold.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Call node.\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], false, true) != \"println\") this.fail(node, \"exact println call required\")\n    const arguments_ = this.arguments(parts[1])\n\n    if (arguments_.length != 1) this.fail(parts[1], \"println 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_expression\") return this.conditional(node)\n    if (node.type == \"call_expression\") return this.print(node)\n    if (node.type == \"jump_expression\") {\n      const parts = this.parts(node)\n\n      if (parts.length != 2 || parts[0].text != \"return\") this.fail(node, \"return expression shape\")\n      this.shape(node, [\"return\", parts[1]])\n      return {expression: this.expression(parts[1]), kind: /** @type {const} */ (\"ReturnStatement\"), location: this.location(node)}\n    }\n    return this.fail(node)\n  }\n\n  /**\n   * Converts an optional parser statement list.\n   * @param {import(\"tree-sitter\").SyntaxNode | undefined} node - Statement-list node.\n   * @returns {import(\"../semantic/types.js\").Statement[]} Semantic statements.\n   */\n  statements(node) {\n    if (!node) return []\n    if (node.type != \"statements\") this.fail(node, \"statement list shape\")\n    return this.parts(node).map((statement) => this.statement(statement))\n  }\n\n  /**\n   * Converts one braced conditional body.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Control body node.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n   */\n  controlBody(node) {\n    const parts = this.parts(node)\n    const statements = parts[1]?.type == \"statements\" ? parts[1] : undefined\n\n    if (node.type != \"control_structure_body\") this.fail(node, \"conditional block 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 strict Boolean conditional.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - If expression 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    const consequence = this.field(node, \"consequence\")\n    const base = [\"if\", \"(\", condition, \")\", consequence]\n\n    if (node.type != \"if_expression\" || consequence.type != \"control_structure_body\") this.fail(node, \"if expression shape\")\n    const statement = /** @type {import(\"../semantic/types.js\").IfStatement} */ ({\n      condition: this.expression(condition), consequent: this.controlBody(consequence), kind: /** @type {const} */ (\"IfStatement\"),\n      location: this.location(node)\n    })\n\n    if (parts.length == base.length) {\n      this.shape(node, base)\n      return statement\n    }\n    const alternative = this.field(node, \"alternative\")\n\n    this.shape(node, [...base, \"else\", alternative])\n    if (alternative.type != \"control_structure_body\") this.fail(alternative, \"if alternate shape\")\n    const alternativeParts = this.parts(alternative)\n\n    if (alternativeParts.length == 1 && alternativeParts[0].type == \"if_expression\") {\n      this.shape(alternative, [alternativeParts[0]])\n      return {...statement, alternate: {kind: /** @type {const} */ (\"Block\"), location: this.location(alternative),\n        statements: [this.conditional(alternativeParts[0])]}}\n    }\n    return {...statement, alternate: this.controlBody(alternative)}\n  }\n\n  /**\n   * Converts one exact braced block.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Block node.\n   * @param {\"function_body\" | \"control_structure_body\"} type - Required parser node type.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n   */\n  block(node, type = \"function_body\") {\n    const parts = this.parts(node)\n    const statements = parts[1]?.type == \"statements\" ? parts[1] : undefined\n\n    if (node.type != type) this.fail(node, `${type} 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 explicitly typed 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 != 3 || parts[0].type != \"simple_identifier\" || parts[1].text != \":\") {\n      this.fail(node, \"parameter shape\")\n    }\n    this.shape(node, [parts[0], \":\", parts[2]])\n    const name = this.identifier(parts[0])\n\n    return withParserRanges({kind: /** @type {const} */ (\"Parameter\"), location: this.location(node), name, type: this.type(parts[2])}, {\n      name: this.location(parts[0])\n    })\n  }\n\n  /**\n   * Converts one supported top-level function.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Function declaration node.\n   * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n   */\n  function(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"function_declaration\" || parts.length < 4 || parts[0].text != \"fun\" || parts[1].type != \"simple_identifier\" ||\n      parts[2].type != \"function_value_parameters\" || parts.at(-1)?.type != \"function_body\") this.fail(node, \"function declaration shape\")\n    if (!parts.some((part) => part.text == \":\")) return missingType(\"kotlin\", \"Function return\", this.location(node))\n    if (parts.length != 6 || parts[3].text != \":\") this.fail(node, \"function declaration shape\")\n    this.shape(node, [\"fun\", parts[1], parts[2], \":\", parts[4], parts[5]])\n    const parameterParts = this.parts(parts[2])\n    const parameters = parameterParts.filter((part) => part.type == \"parameter\")\n\n    if (parameters.length != 2) this.fail(parts[2], \"function parameter count other than two\")\n    this.shape(parts[2], [\"(\", parameters[0], \",\", parameters[1], \")\"])\n    const name = this.identifier(parts[1])\n\n    return withParserRanges({\n      body: this.block(parts[5]), kind: /** @type {const} */ (\"FunctionDeclaration\"), location: this.location(node), name,\n      parameters: parameters.map((parameter) => this.parameter(parameter)), returnType: this.type(parts[4])\n    }, {name: this.location(parts[1])})\n  }\n\n  /**\n   * Converts the exact final main function.\n   * @param {import(\"tree-sitter\").SyntaxNode} node - Main declaration node.\n   * @returns {import(\"../semantic/types.js\").EntryPoint} Semantic entry point.\n   */\n  main(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"function_declaration\" || parts.length != 4 || parts[0].text != \"fun\" ||\n      this.identifier(parts[1], true) != \"main\" || parts[2].type != \"function_value_parameters\" || parts[3].type != \"function_body\") {\n      this.fail(node, \"exact main declaration required\")\n    }\n    this.shape(parts[2], [\"(\", \")\"])\n    this.shape(node, [\"fun\", parts[1], parts[2], parts[3]])\n    return {body: this.block(parts[3]), kind: /** @type {const} */ (\"EntryPoint\"), location: this.location(node)}\n  }\n\n  /**\n   * Compares source support with the canonical generated helper CST.\n   * @param {import(\"tree-sitter\").SyntaxNode} actual - Source node.\n   * @param {import(\"tree-sitter\").SyntaxNode} expected - Canonical support node.\n   * @returns {void}\n   */\n  compareTree(actual, expected) {\n    if (actual.type != expected.type || actual.isNamed != expected.isNamed || actual.isExtra != expected.isExtra ||\n      actual.childCount != expected.childCount) this.fail(actual, \"modified Kotlin support node\")\n    if (!actual.childCount && actual.text != expected.text) this.fail(actual, \"modified Kotlin 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 Kotlin support field\")\n      }\n      this.compareTree(left, right)\n    }\n  }\n\n  /**\n   * Converts and validates one complete Kotlin source file.\n   * @param {import(\"tree-sitter\").SyntaxNode} root - Source file 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 supportTree = parser.parse(kotlinRuntime)\n    const support = this.parts(supportTree.rootNode)\n    let supportIndex = 0\n\n    while (supportIndex < parts.length && supportIndex < support.length && parts[supportIndex].type == support[supportIndex].type) {\n      this.compareTree(parts[supportIndex], support[supportIndex])\n      supportIndex += 1\n    }\n    if (supportIndex > 0 && supportIndex != support.length) this.fail(parts[supportIndex - 1], \"complete Kotlin support required\")\n    this.runtime = supportIndex == support.length\n    const semanticParts = parts.slice(supportIndex)\n    const mainIndex = semanticParts.findIndex((node) => node.type == \"function_declaration\" && this.parts(node)[1]?.text == \"main\")\n\n    if (mainIndex < 0) this.fail(root, \"source file without main\")\n    if (mainIndex == 0) this.fail(semanticParts[0], \"top-level semantic function required\")\n    if (mainIndex != semanticParts.length - 1) this.fail(semanticParts[mainIndex + 1], \"declaration after main\")\n    const declarations = semanticParts.slice(0, mainIndex)\n\n    for (const declaration of declarations) {\n      if (declaration.type != \"function_declaration\") this.fail(declaration)\n    }\n    const module = {\n      entryPoint: this.main(semanticParts[mainIndex]), functions: declarations.map((declaration) => this.function(declaration)),\n      kind: /** @type {const} */ (\"Module\"), location: this.location(root)\n    }\n\n    validateParsedModule(module, \"kotlin\")\n    return module\n  }\n}\n\n/**\n * Parses the strict Task 023 Kotlin/JVM 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 parseKotlin({filename, source}) {\n  if (!hasOnlyUnicodeScalars(source)) {\n    const offset = firstLoneSurrogateOffset(source)\n\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\", language: \"kotlin\", location: locationFromOffsets(filename, source, offset, offset + 1),\n      message: \"Kotlin 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, code: \"PARSE_ERROR\", language: \"kotlin\",\n      location: moduleLocation(filename, source), message: \"The qualified Kotlin parser could not produce a complete CST.\"\n    })\n  }\n  return new KotlinReader(filename, source).module(tree.rootNode)\n}\n"]}