semantifold 0.1.0

package/build/src/frontends/java.js

@@ -0,0 +1,630 @@
+// @ts-check
+import { parser } from "@lezer/java";
+import { SemantifoldDiagnostic, missingType, unsupportedSyntax } from "../diagnostic.js";
+import { locationFromOffsets, moduleLocation } from "../semantic/location.js";
+import { withAdaptedOperation } from "../semantic/operators.js";
+import { withParserRanges } from "../semantic/provenance.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { sourceScalarType } from "./scalars.js";
+/** @type {Readonly<Record<string, string>>} */
+const simpleStringEscapes = Object.freeze({
+    "\"": "\"",
+    "'": "'",
+    "\\": "\\",
+    b: "\b",
+    f: "\f",
+    n: "\n",
+    r: "\r",
+    s: " ",
+    t: "\t"
+});
+const javaBinaryOperations = new Map([
+    ["+", "Add"],
+    ["-", "Subtract"],
+    ["*", "Multiply"],
+    ["&&", "And"],
+    ["||", "Or"],
+    ["==", "JavaEqual"],
+    ["!=", "JavaNotEqual"],
+    ["<", "LessThan"],
+    ["<=", "LessThanOrEqual"],
+    [">", "GreaterThan"],
+    [">=", "GreaterThanOrEqual"]
+]);
+/**
+ * Returns all direct child syntax nodes.
+ * @param {import("@lezer/common").SyntaxNode} node - Parent syntax node.
+ * @returns {import("@lezer/common").SyntaxNode[]} Child syntax nodes.
+ */
+function directChildren(node) {
+    const children = [];
+    for (let child = node.firstChild; child; child = child.nextSibling)
+        children.push(child);
+    return children;
+}
+/**
+ * Returns structural direct children, excluding known grammar delimiters.
+ * @param {import("@lezer/common").SyntaxNode} node - Parent syntax node.
+ * @returns {import("@lezer/common").SyntaxNode[]} Named children.
+ */
+function structuralChildren(node) {
+    return directChildren(node).filter((child) => !["{", "}", "(", ")", ",", ";", "."].includes(child.name));
+}
+/**
+ * Finds all descendant syntax nodes with a given name.
+ * @param {import("@lezer/common").SyntaxNode} node - Root syntax node.
+ * @param {string} name - Node name.
+ * @returns {import("@lezer/common").SyntaxNode[]} Matching descendants.
+ */
+function descendants(node, name) {
+    const matches = [];
+    for (const child of directChildren(node)) {
+        if (child.name == name)
+            matches.push(child);
+        matches.push(...descendants(child, name));
+    }
+    return matches;
+}
+/**
+ * Requires one direct child node.
+ * @param {import("@lezer/common").SyntaxNode} node - Parent node.
+ * @param {string} name - Child name.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("@lezer/common").SyntaxNode} Child node.
+ */
+function requiredChild(node, name, filename, source) {
+    const child = node.getChild(name);
+    if (!child)
+        return unsupportedSyntax("java", `${node.name} without ${name}`, nodeLocation(node, filename, source));
+    return child;
+}
+/**
+ * Returns a normalized Lezer node location.
+ * @param {import("@lezer/common").SyntaxNode} node - Lezer node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Source location.
+ */
+function nodeLocation(node, filename, source) {
+    return locationFromOffsets(filename, source, node.from, node.to);
+}
+/**
+ * Returns source text belonging to a syntax node.
+ * @param {import("@lezer/common").SyntaxNode} node - Lezer node.
+ * @param {string} source - Complete source.
+ * @returns {string} Node text.
+ */
+function nodeText(node, source) {
+    return source.slice(node.from, node.to);
+}
+/**
+ * Converts a supported Java expression node.
+ * @param {import("@lezer/common").SyntaxNode} node - Lezer expression.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Expression} Semantic expression.
+ */
+function convertExpression(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.name == "ParenthesizedExpression") {
+        const children = structuralChildren(node);
+        if (children.length != 1) {
+            return unsupportedSyntax("java", "unsupported parenthesized expression", location);
+        }
+        return convertExpression(children[0], filename, source);
+    }
+    if (node.name == "Identifier") {
+        return withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location, name: nodeText(node, source) }, { name: location });
+    }
+    if (node.name == "IntegerLiteral") {
+        const value = Number(nodeText(node, source));
+        if (!Number.isSafeInteger(value))
+            return unsupportedSyntax("java", "non-safe integer literal", location);
+        return withParserRanges({ kind: /** @type {const} */ ("IntegerLiteral"), location, value }, { literal: location });
+    }
+    if (node.name == "BooleanLiteral") {
+        return withParserRanges({ kind: /** @type {const} */ ("BooleanLiteral"), location, value: nodeText(node, source) == "true" }, { literal: location });
+    }
+    if (node.name == "StringLiteral") {
+        return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: decodeStringLiteral(node, filename, source) }, { literal: location });
+    }
+    if (node.name == "UnaryExpression") {
+        const children = structuralChildren(node);
+        const operatorNode = node.getChild("LogicOp") ?? node.getChild("ArithOp");
+        const operand = children.find((child) => child.name != "LogicOp" && child.name != "ArithOp");
+        const operator = operatorNode ? nodeText(operatorNode, source) : undefined;
+        if (!operatorNode || !operand || children.length != 2 || (operator != "!" && operator != "-")) {
+            return unsupportedSyntax("java", "unary expression", location);
+        }
+        if (operator == "!" && operand.name == "MethodInvocation" && isEqualsInvocation(operand, source)) {
+            return convertStringEquality(operand, true, location, nodeLocation(operatorNode, filename, source), filename, source);
+        }
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand: convertExpression(operand, filename, source)
+        }, { operator: nodeLocation(operatorNode, filename, source) }), operator == "!" ? "Not" : "Negate");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.name == "BinaryExpression") {
+        const named = structuralChildren(node);
+        const operatorNode = node.getChild("CompareOp") ?? node.getChild("ArithOp") ?? node.getChild("LogicOp") ?? node.getChild("BitOp");
+        if (!operatorNode || named.length != 3)
+            return unsupportedSyntax("java", "binary expression", location);
+        const operands = [named[0], named[2]];
+        const unsupportedOperand = operands.find((operand) => !isSupportedExpressionNode(operand));
+        if (unsupportedOperand)
+            return unsupportedSyntax("java", unsupportedOperand.name, nodeLocation(unsupportedOperand, filename, source));
+        const operator = nodeText(operatorNode, source);
+        if (!javaBinaryOperations.has(operator))
+            return unsupportedSyntax("java", `binary ${operator}`, location);
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression",
+            left: convertExpression(operands[0], filename, source),
+            location,
+            right: convertExpression(operands[1], filename, source)
+        }, { operator: nodeLocation(operatorNode, filename, source) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (javaBinaryOperations.get(operator)));
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.name == "MethodInvocation") {
+        if (isEqualsInvocation(node, source)) {
+            const methodName = requiredChild(node, "MethodName", filename, source);
+            return convertStringEquality(node, false, location, nodeLocation(methodName, filename, source), filename, source);
+        }
+        const unsupportedReceiver = structuralChildren(node).find((child) => child.name != "MethodName" && child.name != "ArgumentList");
+        if (unsupportedReceiver)
+            return unsupportedSyntax("java", "method invocation receiver", nodeLocation(unsupportedReceiver, filename, source));
+        const methodName = requiredChild(node, "MethodName", filename, source);
+        const argumentList = requiredChild(node, "ArgumentList", filename, source);
+        const argumentNodes = structuralChildren(argumentList);
+        const unsupportedArgument = argumentNodes.find((child) => !isSupportedExpressionNode(child));
+        if (unsupportedArgument)
+            return unsupportedSyntax("java", `method argument ${unsupportedArgument.name}`, nodeLocation(unsupportedArgument, filename, source));
+        const arguments_ = argumentNodes.map((child) => convertExpression(child, filename, source));
+        return withParserRanges({ arguments: arguments_, callee: nodeText(methodName, source), kind: /** @type {const} */ ("CallExpression"), location }, {
+            callee: nodeLocation(methodName, filename, source)
+        });
+    }
+    return unsupportedSyntax("java", node.name, location);
+}
+/**
+ * Checks the one parser-native Java string equality invocation form.
+ * @param {import("@lezer/common").SyntaxNode} node - Method invocation node.
+ * @param {string} source - Complete source.
+ * @returns {boolean} Whether the invocation spells `.equals` with a receiver.
+ */
+function isEqualsInvocation(node, source) {
+    const methodName = node.getChild("MethodName");
+    const receivers = structuralChildren(node).filter((child) => child.name != "MethodName" && child.name != "ArgumentList");
+    return methodName != null && nodeText(methodName, source) == "equals" && receivers.length == 1;
+}
+/**
+ * Converts Java `.equals` or its directly negated form without source-text inference.
+ * @param {import("@lezer/common").SyntaxNode} node - Parser method invocation.
+ * @param {boolean} negated - Whether a parser-owned unary not wraps the invocation.
+ * @param {import("../semantic/types.js").SourceLocation} location - Whole equality expression location.
+ * @param {import("../semantic/types.js").SourceLocation} operatorLocation - Parser-owned operator/method location.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Expression} Adapted equality expression.
+ */
+function convertStringEquality(node, negated, location, operatorLocation, filename, source) {
+    const argumentList = requiredChild(node, "ArgumentList", filename, source);
+    const arguments_ = structuralChildren(argumentList);
+    const receivers = structuralChildren(node).filter((child) => child.name != "MethodName" && child.name != "ArgumentList");
+    const unsupportedArgument = arguments_.find((child) => !isSupportedExpressionNode(child));
+    if (receivers.length != 1 || arguments_.length != 1 || unsupportedArgument) {
+        return unsupportedSyntax("java", "string equals invocation", nodeLocation(node, filename, source));
+    }
+    /** @type {Record<string, import("../semantic/types.js").SourceLocation>} */
+    const ranges = { operator: operatorLocation };
+    if (negated) {
+        ranges.equalityOperator = nodeLocation(requiredChild(node, "MethodName", filename, source), filename, source);
+    }
+    const semantic = withAdaptedOperation(withParserRanges({
+        kind: "BinaryExpression",
+        left: convertExpression(receivers[0], filename, source),
+        location,
+        right: convertExpression(arguments_[0], filename, source)
+    }, ranges), negated ? "StringNotEqual" : "StringEqual");
+    return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+}
+/**
+ * Checks whether a Lezer node is in the expression subset.
+ * @param {import("@lezer/common").SyntaxNode} node - Java syntax node.
+ * @returns {boolean} Whether the node is supported.
+ */
+function isSupportedExpressionNode(node) {
+    return [
+        "Identifier",
+        "IntegerLiteral",
+        "BooleanLiteral",
+        "StringLiteral",
+        "UnaryExpression",
+        "BinaryExpression",
+        "MethodInvocation",
+        "ParenthesizedExpression"
+    ].includes(node.name);
+}
+/**
+ * Applies Java Unicode translation before token-level string escape decoding.
+ * @param {string} literal - Parser-confirmed Java string literal.
+ * @param {import("../semantic/types.js").SourceLocation} location - Literal source location.
+ * @returns {string} Unicode-translated literal.
+ */
+function translateUnicodeEscapes(literal, location) {
+    let translated = "";
+    let consecutiveBackslashes = 0;
+    let previousWasUnicodeEscape = false;
+    for (let index = 0; index < literal.length; index++) {
+        const character = literal[index];
+        const eligible = character == "\\" && (previousWasUnicodeEscape || consecutiveBackslashes % 2 == 0);
+        if (eligible && literal[index + 1] == "u") {
+            let digitsStart = index + 2;
+            while (literal[digitsStart] == "u")
+                digitsStart++;
+            const hexadecimal = literal.slice(digitsStart, digitsStart + 4);
+            const isHexadecimal = hexadecimal.length == 4 && [...hexadecimal].every((digit) => (digit >= "0" && digit <= "9") || (digit >= "A" && digit <= "F") || (digit >= "a" && digit <= "f"));
+            if (!isHexadecimal)
+                return unsupportedSyntax("java", "unsupported string escape", location);
+            const translatedCharacter = String.fromCharCode(Number.parseInt(hexadecimal, 16));
+            translated += translatedCharacter;
+            consecutiveBackslashes = translatedCharacter == "\\" ? consecutiveBackslashes + 1 : 0;
+            previousWasUnicodeEscape = true;
+            index = digitsStart + 3;
+            continue;
+        }
+        translated += character;
+        consecutiveBackslashes = character == "\\" ? consecutiveBackslashes + 1 : 0;
+        previousWasUnicodeEscape = false;
+    }
+    return translated;
+}
+/**
+ * Decodes the accepted escapes from one parser-confirmed Java string literal.
+ * @param {import("@lezer/common").SyntaxNode} node - Java StringLiteral node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {string} Decoded Unicode string.
+ */
+function decodeStringLiteral(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const literal = translateUnicodeEscapes(nodeText(node, source), location);
+    let value = "";
+    for (let index = 1; index < literal.length - 1; index++) {
+        const character = literal[index];
+        if (character == "\"" || character == "\n" || character == "\r") {
+            return unsupportedSyntax("java", "invalid string literal", location);
+        }
+        if (character != "\\") {
+            value += character;
+            continue;
+        }
+        if (index + 1 >= literal.length - 1)
+            return unsupportedSyntax("java", "invalid string literal", location);
+        const escaped = literal[++index];
+        const simple = simpleStringEscapes[escaped];
+        if (simple !== undefined) {
+            value += simple;
+            continue;
+        }
+        if (escaped >= "0" && escaped <= "7") {
+            let octal = escaped;
+            const maximumLength = escaped <= "3" ? 3 : 2;
+            while (octal.length < maximumLength && literal[index + 1] >= "0" && literal[index + 1] <= "7") {
+                octal += literal[++index];
+            }
+            value += String.fromCharCode(Number.parseInt(octal, 8));
+            continue;
+        }
+        return unsupportedSyntax("java", "unsupported string escape", location);
+    }
+    if (!hasOnlyUnicodeScalars(value))
+        return unsupportedSyntax("java", "invalid Unicode string literal", location);
+    return value;
+}
+/**
+ * Converts one explicit Java return statement.
+ * @param {import("@lezer/common").SyntaxNode} statement - Java statement.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").ReturnStatement} Semantic return.
+ */
+function convertReturn(statement, filename, source) {
+    const location = nodeLocation(statement, filename, source);
+    if (statement.name != "ReturnStatement")
+        return unsupportedSyntax("java", statement.name, location);
+    const expressionNodes = directChildren(statement).filter((child) => child.name != "return" && child.name != ";");
+    const expression = expressionNodes.length == 1 ? expressionNodes[0] : undefined;
+    if (!expression) {
+        const unsupported = expressionNodes[0];
+        return unsupportedSyntax("java", unsupported?.name ?? "empty return", unsupported ? nodeLocation(unsupported, filename, source) : location);
+    }
+    return { expression: convertExpression(expression, filename, source), kind: "ReturnStatement", location };
+}
+/**
+ * Converts one Java local declaration or assignment.
+ * @param {import("@lezer/common").SyntaxNode} statement - Java statement.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").LocalStatement} Semantic local statement.
+ */
+function convertLocalStatement(statement, filename, source) {
+    const location = nodeLocation(statement, filename, source);
+    if (statement.name == "LocalVariableDeclaration") {
+        const declarators = statement.getChildren("VariableDeclarator");
+        const typeNode = declarationType(statement);
+        const varNode = statement.getChild("var");
+        const modifiers = statement.getChild("Modifiers");
+        const modifierChildren = modifiers ? structuralChildren(modifiers) : [];
+        if (varNode)
+            return unsupportedSyntax("java", "var local declaration", nodeLocation(varNode, filename, source));
+        if (declarators.length != 1)
+            return unsupportedSyntax("java", "multiple local declarators", location);
+        if (!typeNode || typeNode.name == "ArrayType")
+            return unsupportedSyntax("java", "unsupported local type", location);
+        if (modifierChildren.some((child) => child.name != "final") || modifierChildren.length > 1) {
+            return unsupportedSyntax("java", "unsupported local modifiers", modifiers ? nodeLocation(modifiers, filename, source) : location);
+        }
+        const declarator = declarators[0];
+        const definition = requiredChild(declarator, "Definition", filename, source);
+        const assignment = declarator.getChild("AssignOp");
+        const dimensions = declarator.getChildren("Dimension");
+        const initializerNodes = directChildren(declarator).filter((child) => child.name != "Definition" && child.name != "AssignOp");
+        if (dimensions.length > 0)
+            return unsupportedSyntax("java", "array local declaration", nodeLocation(declarator, filename, source));
+        if (!assignment || nodeText(assignment, source) != "=" || initializerNodes.length != 1) {
+            return unsupportedSyntax("java", "uninitialized local declaration", nodeLocation(declarator, filename, source));
+        }
+        const name = nodeText(definition, source);
+        return withParserRanges({
+            initializer: convertExpression(initializerNodes[0], filename, source),
+            kind: "LocalDeclaration",
+            location,
+            mutable: modifierChildren.length == 0,
+            name,
+            type: convertType(typeNode, `Local '${name}'`, location, filename, source)
+        }, { name: nodeLocation(definition, filename, source), operator: nodeLocation(assignment, filename, source) });
+    }
+    if (statement.name == "ExpressionStatement") {
+        const assignment = statement.getChild("AssignmentExpression");
+        if (!assignment)
+            return unsupportedSyntax("java", statement.name, location);
+        const children = structuralChildren(assignment);
+        const operator = assignment.getChild("AssignOp");
+        const target = children[0];
+        const expression = children.at(-1);
+        if (!operator || nodeText(operator, source) != "=")
+            return unsupportedSyntax("java", "compound assignment", nodeLocation(assignment, filename, source));
+        if (!target || target.name != "Identifier")
+            return unsupportedSyntax("java", target?.name ?? "assignment target", target ? nodeLocation(target, filename, source) : location);
+        if (!expression || expression == target || expression == operator)
+            return unsupportedSyntax("java", "assignment expression", nodeLocation(assignment, filename, source));
+        const targetExpression = withParserRanges({
+            kind: /** @type {const} */ ("IdentifierExpression"),
+            location: nodeLocation(target, filename, source),
+            name: nodeText(target, source)
+        }, { name: nodeLocation(target, filename, source) });
+        return withParserRanges({
+            expression: convertExpression(expression, filename, source),
+            kind: "AssignmentStatement",
+            location,
+            target: targetExpression
+        }, { operator: nodeLocation(operator, filename, source) });
+    }
+    return unsupportedSyntax("java", statement.name, location);
+}
+/**
+ * Converts one exhaustive direct Java block child.
+ * @param {import("@lezer/common").SyntaxNode} statement - Java statement.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Statement} Semantic statement.
+ */
+function convertStatement(statement, filename, source) {
+    if (statement.name == "ReturnStatement")
+        return convertReturn(statement, filename, source);
+    if (statement.name == "IfStatement")
+        return convertIf(statement, filename, source);
+    if (statement.name == "LocalVariableDeclaration")
+        return convertLocalStatement(statement, filename, source);
+    if (statement.name == "ExpressionStatement") {
+        if (statement.getChild("AssignmentExpression"))
+            return convertLocalStatement(statement, filename, source);
+        if (!statement.getChild("MethodInvocation")) {
+            return unsupportedSyntax("java", statement.name, nodeLocation(statement, filename, source));
+        }
+        return convertPrint(statement, filename, source);
+    }
+    return unsupportedSyntax("java", statement.name, nodeLocation(statement, filename, source));
+}
+/**
+ * Converts direct structural children of one Java block in source order.
+ * @param {import("@lezer/common").SyntaxNode} node - Java Block node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Block} Semantic block.
+ */
+function convertBlock(node, filename, source) {
+    if (node.name != "Block")
+        return unsupportedSyntax("java", `expected block, received ${node.name}`, nodeLocation(node, filename, source));
+    return {
+        kind: "Block",
+        location: nodeLocation(node, filename, source),
+        statements: structuralChildren(node).map((statement) => convertStatement(statement, filename, source))
+    };
+}
+/**
+ * Requires an exact Java scalar type node.
+ * @param {import("@lezer/common").SyntaxNode | null} sourceType - Java type node.
+ * @param {string} subject - Typed subject.
+ * @param {import("../semantic/types.js").SourceLocation} location - Source location.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").TypeReference} Semantic type.
+ */
+function convertType(sourceType, subject, location, filename, source) {
+    if (!sourceType)
+        return missingType("java", subject, location);
+    if (!["PrimitiveType", "TypeName", "ScopedTypeName"].includes(sourceType.name)) {
+        return unsupportedSyntax("java", "unsupported scalar type", location);
+    }
+    const type = sourceScalarType("java", nodeText(sourceType, source), nodeLocation(sourceType, filename, source));
+    if (!type)
+        return unsupportedSyntax("java", "unsupported scalar type", nodeLocation(sourceType, location.filename, source));
+    return type;
+}
+/**
+ * Returns the direct Java declaration type node supported by scalar conversion.
+ * @param {import("@lezer/common").SyntaxNode} node - Declaration node.
+ * @returns {import("@lezer/common").SyntaxNode | null} Type syntax node.
+ */
+function declarationType(node) {
+    return node.getChild("PrimitiveType") ?? node.getChild("TypeName") ?? node.getChild("ScopedTypeName");
+}
+/**
+ * Converts the supported Java function method.
+ * @param {import("@lezer/common").SyntaxNode} node - Method declaration.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+ */
+function convertFunction(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const definition = requiredChild(node, "Definition", filename, source);
+    const name = nodeText(definition, source);
+    const parametersNode = requiredChild(node, "FormalParameters", filename, source);
+    const parameters = parametersNode.getChildren("FormalParameter").map((parameter) => {
+        const parameterLocation = nodeLocation(parameter, filename, source);
+        const parameterNameNode = requiredChild(parameter, "Definition", filename, source);
+        const parameterName = nodeText(parameterNameNode, source);
+        const semanticParameter = {
+            kind: /** @type {const} */ ("Parameter"),
+            location: parameterLocation,
+            name: parameterName,
+            type: convertType(declarationType(parameter), `Parameter '${parameterName}'`, parameterLocation, filename, source)
+        };
+        return withParserRanges(semanticParameter, { name: nodeLocation(parameterNameNode, filename, source) });
+    });
+    const block = requiredChild(node, "Block", filename, source);
+    const body = convertBlock(block, filename, source);
+    return withParserRanges({
+        body,
+        kind: "FunctionDeclaration",
+        location,
+        name,
+        parameters,
+        returnType: convertType(declarationType(node), `Function '${name}' return`, location, filename, source)
+    }, { name: nodeLocation(definition, filename, source) });
+}
+/**
+ * Converts the existing exact Java if/else terminal with restricted branch prefixes.
+ * @param {import("@lezer/common").SyntaxNode} node - Java if statement.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").IfStatement} Semantic branch.
+ */
+function convertIf(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const conditionContainer = requiredChild(node, "ParenthesizedExpression", filename, source);
+    const conditionNodes = structuralChildren(conditionContainer);
+    const condition = conditionNodes.length == 1 ? conditionNodes[0] : undefined;
+    const direct = directChildren(node);
+    const conditionIndex = direct.findIndex((child) => child.name == conditionContainer.name &&
+        child.from == conditionContainer.from && child.to == conditionContainer.to);
+    const consequentNode = direct[conditionIndex + 1];
+    const alternateNode = direct.at(-1) == consequentNode ? undefined : direct.at(-1);
+    if (!condition || !consequentNode || consequentNode.name != "Block") {
+        return unsupportedSyntax("java", "if without block consequent", location);
+    }
+    let alternate;
+    if (alternateNode?.name == "Block")
+        alternate = convertBlock(alternateNode, filename, source);
+    else if (alternateNode?.name == "IfStatement") {
+        alternate = {
+            kind: /** @type {const} */ ("Block"),
+            location: nodeLocation(alternateNode, filename, source),
+            statements: [convertIf(alternateNode, filename, source)]
+        };
+    }
+    else if (alternateNode && alternateNode.name != "else") {
+        return unsupportedSyntax("java", `if alternate ${alternateNode.name}`, nodeLocation(alternateNode, filename, source));
+    }
+    return {
+        ...(alternate ? { alternate } : {}),
+        condition: convertExpression(condition, filename, source),
+        consequent: convertBlock(consequentNode, filename, source),
+        kind: "IfStatement",
+        location
+    };
+}
+/**
+ * Converts Java's supported main method.
+ * @param {import("@lezer/common").SyntaxNode} node - Main method.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").EntryPoint} Semantic entry point.
+ */
+function convertEntryPoint(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const block = requiredChild(node, "Block", filename, source);
+    const body = convertBlock(block, filename, source);
+    return { body, kind: "EntryPoint", location };
+}
+/**
+ * Converts one supported Java print statement.
+ * @param {import("@lezer/common").SyntaxNode} statement - Expression statement.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").PrintStatement} Semantic print.
+ */
+function convertPrint(statement, filename, source) {
+    const location = nodeLocation(statement, filename, source);
+    const printInvocation = statement.getChild("MethodInvocation");
+    if (!printInvocation)
+        return unsupportedSyntax("java", "main without System.out.println", location);
+    const fieldAccess = printInvocation.getChild("FieldAccess");
+    const methodName = printInvocation.getChild("MethodName");
+    if (!fieldAccess || !methodName || nodeText(fieldAccess, source) != "System.out" || nodeText(methodName, source) != "println") {
+        return unsupportedSyntax("java", "main without System.out.println", nodeLocation(printInvocation, filename, source));
+    }
+    const argumentList = requiredChild(printInvocation, "ArgumentList", filename, source);
+    const arguments_ = structuralChildren(argumentList);
+    if (arguments_.length != 1) {
+        return unsupportedSyntax("java", "println without one supported argument", nodeLocation(argumentList, filename, source));
+    }
+    const printLocation = nodeLocation(printInvocation, filename, source);
+    return { expression: convertExpression(arguments_[0], filename, source), kind: "PrintStatement", location: printLocation };
+}
+/**
+ * Parses Java into the shared semantic module.
+ * @param {object} input - Parser input.
+ * @param {string} input.filename - Source filename.
+ * @param {string} input.source - Source text.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parseJava({ filename, source }) {
+    const tree = parser.parse(source);
+    const error = descendants(tree.topNode, "⚠")[0];
+    if (error) {
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR",
+            language: "java",
+            location: nodeLocation(error, filename, source),
+            message: "Java parser reported invalid syntax."
+        });
+    }
+    const methods = descendants(tree.topNode, "MethodDeclaration");
+    const mainMethod = methods.find((method) => nodeText(requiredChild(method, "Definition", filename, source), source) == "main");
+    const functionMethods = methods.filter((method) => method != mainMethod);
+    const location = moduleLocation(filename, source);
+    if (functionMethods.length == 0)
+        return unsupportedSyntax("java", "class without a semantic function", location);
+    if (!mainMethod)
+        return unsupportedSyntax("java", "class without main", location);
+    const functions = functionMethods.map((method) => convertFunction(method, filename, source));
+    const entryPoint = convertEntryPoint(mainMethod, filename, source);
+    return { entryPoint, functions, kind: "Module", location };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"java.js","sourceRoot":"","sources":["../../../src/frontends/java.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {parser} from \"@lezer/java\"\nimport {SemantifoldDiagnostic, missingType, unsupportedSyntax} from \"../diagnostic.js\"\nimport {locationFromOffsets, moduleLocation} from \"../semantic/location.js\"\nimport {withAdaptedOperation} from \"../semantic/operators.js\"\nimport {withParserRanges} from \"../semantic/provenance.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {sourceScalarType} from \"./scalars.js\"\n\n/** @type {Readonly<Record<string, string>>} */\nconst simpleStringEscapes = Object.freeze({\n  \"\\\"\": \"\\\"\",\n  \"'\": \"'\",\n  \"\\\\\": \"\\\\\",\n  b: \"\\b\",\n  f: \"\\f\",\n  n: \"\\n\",\n  r: \"\\r\",\n  s: \" \",\n  t: \"\\t\"\n})\nconst javaBinaryOperations = new Map([\n  [\"+\", \"Add\"],\n  [\"-\", \"Subtract\"],\n  [\"*\", \"Multiply\"],\n  [\"&&\", \"And\"],\n  [\"||\", \"Or\"],\n  [\"==\", \"JavaEqual\"],\n  [\"!=\", \"JavaNotEqual\"],\n  [\"<\", \"LessThan\"],\n  [\"<=\", \"LessThanOrEqual\"],\n  [\">\", \"GreaterThan\"],\n  [\">=\", \"GreaterThanOrEqual\"]\n])\n\n/**\n * Returns all direct child syntax nodes.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Parent syntax node.\n * @returns {import(\"@lezer/common\").SyntaxNode[]} Child syntax nodes.\n */\nfunction directChildren(node) {\n  const children = []\n\n  for (let child = node.firstChild; child; child = child.nextSibling) children.push(child)\n\n  return children\n}\n\n/**\n * Returns structural direct children, excluding known grammar delimiters.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Parent syntax node.\n * @returns {import(\"@lezer/common\").SyntaxNode[]} Named children.\n */\nfunction structuralChildren(node) {\n  return directChildren(node).filter((child) => ![\"{\", \"}\", \"(\", \")\", \",\", \";\", \".\"].includes(child.name))\n}\n\n/**\n * Finds all descendant syntax nodes with a given name.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Root syntax node.\n * @param {string} name - Node name.\n * @returns {import(\"@lezer/common\").SyntaxNode[]} Matching descendants.\n */\nfunction descendants(node, name) {\n  const matches = []\n\n  for (const child of directChildren(node)) {\n    if (child.name == name) matches.push(child)\n    matches.push(...descendants(child, name))\n  }\n\n  return matches\n}\n\n/**\n * Requires one direct child node.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Parent node.\n * @param {string} name - Child name.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"@lezer/common\").SyntaxNode} Child node.\n */\nfunction requiredChild(node, name, filename, source) {\n  const child = node.getChild(name)\n\n  if (!child) return unsupportedSyntax(\"java\", `${node.name} without ${name}`, nodeLocation(node, filename, source))\n\n  return child\n}\n\n/**\n * Returns a normalized Lezer node location.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Lezer node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Source location.\n */\nfunction nodeLocation(node, filename, source) {\n  return locationFromOffsets(filename, source, node.from, node.to)\n}\n\n/**\n * Returns source text belonging to a syntax node.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Lezer node.\n * @param {string} source - Complete source.\n * @returns {string} Node text.\n */\nfunction nodeText(node, source) {\n  return source.slice(node.from, node.to)\n}\n\n/**\n * Converts a supported Java expression node.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Lezer expression.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n */\nfunction convertExpression(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.name == \"ParenthesizedExpression\") {\n    const children = structuralChildren(node)\n\n    if (children.length != 1) {\n      return unsupportedSyntax(\"java\", \"unsupported parenthesized expression\", location)\n    }\n\n    return convertExpression(children[0], filename, source)\n  }\n\n  if (node.name == \"Identifier\") {\n    return withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location, name: nodeText(node, source)}, {name: location})\n  }\n\n  if (node.name == \"IntegerLiteral\") {\n    const value = Number(nodeText(node, source))\n\n    if (!Number.isSafeInteger(value)) return unsupportedSyntax(\"java\", \"non-safe integer literal\", location)\n\n    return withParserRanges({kind: /** @type {const} */ (\"IntegerLiteral\"), location, value}, {literal: location})\n  }\n\n  if (node.name == \"BooleanLiteral\") {\n    return withParserRanges({kind: /** @type {const} */ (\"BooleanLiteral\"), location, value: nodeText(node, source) == \"true\"}, {literal: location})\n  }\n\n  if (node.name == \"StringLiteral\") {\n    return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: decodeStringLiteral(node, filename, source)}, {literal: location})\n  }\n\n  if (node.name == \"UnaryExpression\") {\n    const children = structuralChildren(node)\n    const operatorNode = node.getChild(\"LogicOp\") ?? node.getChild(\"ArithOp\")\n    const operand = children.find((child) => child.name != \"LogicOp\" && child.name != \"ArithOp\")\n    const operator = operatorNode ? nodeText(operatorNode, source) : undefined\n\n    if (!operatorNode || !operand || children.length != 2 || (operator != \"!\" && operator != \"-\")) {\n      return unsupportedSyntax(\"java\", \"unary expression\", location)\n    }\n\n    if (operator == \"!\" && operand.name == \"MethodInvocation\" && isEqualsInvocation(operand, source)) {\n      return convertStringEquality(operand, true, location, nodeLocation(operatorNode, filename, source), filename, source)\n    }\n\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand: convertExpression(operand, filename, source)\n    }, {operator: nodeLocation(operatorNode, filename, source)}), operator == \"!\" ? \"Not\" : \"Negate\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node.name == \"BinaryExpression\") {\n    const named = structuralChildren(node)\n    const operatorNode = node.getChild(\"CompareOp\") ?? node.getChild(\"ArithOp\") ?? node.getChild(\"LogicOp\") ?? node.getChild(\"BitOp\")\n\n    if (!operatorNode || named.length != 3) return unsupportedSyntax(\"java\", \"binary expression\", location)\n\n    const operands = [named[0], named[2]]\n    const unsupportedOperand = operands.find((operand) => !isSupportedExpressionNode(operand))\n\n    if (unsupportedOperand) return unsupportedSyntax(\"java\", unsupportedOperand.name, nodeLocation(unsupportedOperand, filename, source))\n\n    const operator = nodeText(operatorNode, source)\n\n    if (!javaBinaryOperations.has(operator)) return unsupportedSyntax(\"java\", `binary ${operator}`, location)\n\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\",\n      left: convertExpression(operands[0], filename, source),\n      location,\n      right: convertExpression(operands[1], filename, source)\n    }, {operator: nodeLocation(operatorNode, filename, source)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (javaBinaryOperations.get(operator)))\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node.name == \"MethodInvocation\") {\n    if (isEqualsInvocation(node, source)) {\n      const methodName = requiredChild(node, \"MethodName\", filename, source)\n\n      return convertStringEquality(node, false, location, nodeLocation(methodName, filename, source), filename, source)\n    }\n\n    const unsupportedReceiver = structuralChildren(node).find((child) => child.name != \"MethodName\" && child.name != \"ArgumentList\")\n\n    if (unsupportedReceiver) return unsupportedSyntax(\"java\", \"method invocation receiver\", nodeLocation(unsupportedReceiver, filename, source))\n\n    const methodName = requiredChild(node, \"MethodName\", filename, source)\n    const argumentList = requiredChild(node, \"ArgumentList\", filename, source)\n    const argumentNodes = structuralChildren(argumentList)\n    const unsupportedArgument = argumentNodes.find((child) => !isSupportedExpressionNode(child))\n\n    if (unsupportedArgument) return unsupportedSyntax(\"java\", `method argument ${unsupportedArgument.name}`, nodeLocation(unsupportedArgument, filename, source))\n\n    const arguments_ = argumentNodes.map((child) => convertExpression(child, filename, source))\n\n    return withParserRanges({arguments: arguments_, callee: nodeText(methodName, source), kind: /** @type {const} */ (\"CallExpression\"), location}, {\n      callee: nodeLocation(methodName, filename, source)\n    })\n  }\n\n  return unsupportedSyntax(\"java\", node.name, location)\n}\n\n/**\n * Checks the one parser-native Java string equality invocation form.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Method invocation node.\n * @param {string} source - Complete source.\n * @returns {boolean} Whether the invocation spells `.equals` with a receiver.\n */\nfunction isEqualsInvocation(node, source) {\n  const methodName = node.getChild(\"MethodName\")\n  const receivers = structuralChildren(node).filter((child) => child.name != \"MethodName\" && child.name != \"ArgumentList\")\n\n  return methodName != null && nodeText(methodName, source) == \"equals\" && receivers.length == 1\n}\n\n/**\n * Converts Java `.equals` or its directly negated form without source-text inference.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Parser method invocation.\n * @param {boolean} negated - Whether a parser-owned unary not wraps the invocation.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Whole equality expression location.\n * @param {import(\"../semantic/types.js\").SourceLocation} operatorLocation - Parser-owned operator/method location.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Expression} Adapted equality expression.\n */\nfunction convertStringEquality(node, negated, location, operatorLocation, filename, source) {\n  const argumentList = requiredChild(node, \"ArgumentList\", filename, source)\n  const arguments_ = structuralChildren(argumentList)\n  const receivers = structuralChildren(node).filter((child) => child.name != \"MethodName\" && child.name != \"ArgumentList\")\n  const unsupportedArgument = arguments_.find((child) => !isSupportedExpressionNode(child))\n\n  if (receivers.length != 1 || arguments_.length != 1 || unsupportedArgument) {\n    return unsupportedSyntax(\"java\", \"string equals invocation\", nodeLocation(node, filename, source))\n  }\n\n  /** @type {Record<string, import(\"../semantic/types.js\").SourceLocation>} */\n  const ranges = {operator: operatorLocation}\n\n  if (negated) {\n    ranges.equalityOperator = nodeLocation(requiredChild(node, \"MethodName\", filename, source), filename, source)\n  }\n\n  const semantic = withAdaptedOperation(withParserRanges({\n    kind: \"BinaryExpression\",\n    left: convertExpression(receivers[0], filename, source),\n    location,\n    right: convertExpression(arguments_[0], filename, source)\n  }, ranges), negated ? \"StringNotEqual\" : \"StringEqual\")\n\n  return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n}\n\n/**\n * Checks whether a Lezer node is in the expression subset.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Java syntax node.\n * @returns {boolean} Whether the node is supported.\n */\nfunction isSupportedExpressionNode(node) {\n  return [\n    \"Identifier\",\n    \"IntegerLiteral\",\n    \"BooleanLiteral\",\n    \"StringLiteral\",\n    \"UnaryExpression\",\n    \"BinaryExpression\",\n    \"MethodInvocation\",\n    \"ParenthesizedExpression\"\n  ].includes(node.name)\n}\n\n/**\n * Applies Java Unicode translation before token-level string escape decoding.\n * @param {string} literal - Parser-confirmed Java string literal.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Literal source location.\n * @returns {string} Unicode-translated literal.\n */\nfunction translateUnicodeEscapes(literal, location) {\n  let translated = \"\"\n  let consecutiveBackslashes = 0\n  let previousWasUnicodeEscape = false\n\n  for (let index = 0; index < literal.length; index++) {\n    const character = literal[index]\n    const eligible = character == \"\\\\\" && (previousWasUnicodeEscape || consecutiveBackslashes % 2 == 0)\n\n    if (eligible && literal[index + 1] == \"u\") {\n      let digitsStart = index + 2\n\n      while (literal[digitsStart] == \"u\") digitsStart++\n\n      const hexadecimal = literal.slice(digitsStart, digitsStart + 4)\n      const isHexadecimal = hexadecimal.length == 4 && [...hexadecimal].every((digit) =>\n        (digit >= \"0\" && digit <= \"9\") || (digit >= \"A\" && digit <= \"F\") || (digit >= \"a\" && digit <= \"f\")\n      )\n\n      if (!isHexadecimal) return unsupportedSyntax(\"java\", \"unsupported string escape\", location)\n\n      const translatedCharacter = String.fromCharCode(Number.parseInt(hexadecimal, 16))\n\n      translated += translatedCharacter\n      consecutiveBackslashes = translatedCharacter == \"\\\\\" ? consecutiveBackslashes + 1 : 0\n      previousWasUnicodeEscape = true\n      index = digitsStart + 3\n      continue\n    }\n\n    translated += character\n    consecutiveBackslashes = character == \"\\\\\" ? consecutiveBackslashes + 1 : 0\n    previousWasUnicodeEscape = false\n  }\n\n  return translated\n}\n\n/**\n * Decodes the accepted escapes from one parser-confirmed Java string literal.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Java StringLiteral node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {string} Decoded Unicode string.\n */\nfunction decodeStringLiteral(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const literal = translateUnicodeEscapes(nodeText(node, source), location)\n  let value = \"\"\n\n  for (let index = 1; index < literal.length - 1; index++) {\n    const character = literal[index]\n\n    if (character == \"\\\"\" || character == \"\\n\" || character == \"\\r\") {\n      return unsupportedSyntax(\"java\", \"invalid string literal\", location)\n    }\n\n    if (character != \"\\\\\") {\n      value += character\n      continue\n    }\n\n    if (index + 1 >= literal.length - 1) return unsupportedSyntax(\"java\", \"invalid string literal\", location)\n\n    const escaped = literal[++index]\n    const simple = simpleStringEscapes[escaped]\n\n    if (simple !== undefined) {\n      value += simple\n      continue\n    }\n\n    if (escaped >= \"0\" && escaped <= \"7\") {\n      let octal = escaped\n      const maximumLength = escaped <= \"3\" ? 3 : 2\n\n      while (octal.length < maximumLength && literal[index + 1] >= \"0\" && literal[index + 1] <= \"7\") {\n        octal += literal[++index]\n      }\n\n      value += String.fromCharCode(Number.parseInt(octal, 8))\n      continue\n    }\n\n    return unsupportedSyntax(\"java\", \"unsupported string escape\", location)\n  }\n\n  if (!hasOnlyUnicodeScalars(value)) return unsupportedSyntax(\"java\", \"invalid Unicode string literal\", location)\n\n  return value\n}\n\n/**\n * Converts one explicit Java return statement.\n * @param {import(\"@lezer/common\").SyntaxNode} statement - Java statement.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").ReturnStatement} Semantic return.\n */\nfunction convertReturn(statement, filename, source) {\n  const location = nodeLocation(statement, filename, source)\n\n  if (statement.name != \"ReturnStatement\") return unsupportedSyntax(\"java\", statement.name, location)\n\n  const expressionNodes = directChildren(statement).filter((child) => child.name != \"return\" && child.name != \";\")\n  const expression = expressionNodes.length == 1 ? expressionNodes[0] : undefined\n\n  if (!expression) {\n    const unsupported = expressionNodes[0]\n\n    return unsupportedSyntax(\n      \"java\",\n      unsupported?.name ?? \"empty return\",\n      unsupported ? nodeLocation(unsupported, filename, source) : location\n    )\n  }\n\n  return {expression: convertExpression(expression, filename, source), kind: \"ReturnStatement\", location}\n}\n\n/**\n * Converts one Java local declaration or assignment.\n * @param {import(\"@lezer/common\").SyntaxNode} statement - Java statement.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").LocalStatement} Semantic local statement.\n */\nfunction convertLocalStatement(statement, filename, source) {\n  const location = nodeLocation(statement, filename, source)\n\n  if (statement.name == \"LocalVariableDeclaration\") {\n    const declarators = statement.getChildren(\"VariableDeclarator\")\n    const typeNode = declarationType(statement)\n    const varNode = statement.getChild(\"var\")\n    const modifiers = statement.getChild(\"Modifiers\")\n    const modifierChildren = modifiers ? structuralChildren(modifiers) : []\n\n    if (varNode) return unsupportedSyntax(\"java\", \"var local declaration\", nodeLocation(varNode, filename, source))\n    if (declarators.length != 1) return unsupportedSyntax(\"java\", \"multiple local declarators\", location)\n    if (!typeNode || typeNode.name == \"ArrayType\") return unsupportedSyntax(\"java\", \"unsupported local type\", location)\n    if (modifierChildren.some((child) => child.name != \"final\") || modifierChildren.length > 1) {\n      return unsupportedSyntax(\"java\", \"unsupported local modifiers\", modifiers ? nodeLocation(modifiers, filename, source) : location)\n    }\n\n    const declarator = declarators[0]\n    const definition = requiredChild(declarator, \"Definition\", filename, source)\n    const assignment = declarator.getChild(\"AssignOp\")\n    const dimensions = declarator.getChildren(\"Dimension\")\n    const initializerNodes = directChildren(declarator).filter((child) => child.name != \"Definition\" && child.name != \"AssignOp\")\n\n    if (dimensions.length > 0) return unsupportedSyntax(\"java\", \"array local declaration\", nodeLocation(declarator, filename, source))\n    if (!assignment || nodeText(assignment, source) != \"=\" || initializerNodes.length != 1) {\n      return unsupportedSyntax(\"java\", \"uninitialized local declaration\", nodeLocation(declarator, filename, source))\n    }\n\n    const name = nodeText(definition, source)\n\n    return withParserRanges({\n      initializer: convertExpression(initializerNodes[0], filename, source),\n      kind: \"LocalDeclaration\",\n      location,\n      mutable: modifierChildren.length == 0,\n      name,\n      type: convertType(typeNode, `Local '${name}'`, location, filename, source)\n    }, {name: nodeLocation(definition, filename, source), operator: nodeLocation(assignment, filename, source)})\n  }\n\n  if (statement.name == \"ExpressionStatement\") {\n    const assignment = statement.getChild(\"AssignmentExpression\")\n\n    if (!assignment) return unsupportedSyntax(\"java\", statement.name, location)\n\n    const children = structuralChildren(assignment)\n    const operator = assignment.getChild(\"AssignOp\")\n    const target = children[0]\n    const expression = children.at(-1)\n\n    if (!operator || nodeText(operator, source) != \"=\") return unsupportedSyntax(\"java\", \"compound assignment\", nodeLocation(assignment, filename, source))\n    if (!target || target.name != \"Identifier\") return unsupportedSyntax(\"java\", target?.name ?? \"assignment target\", target ? nodeLocation(target, filename, source) : location)\n    if (!expression || expression == target || expression == operator) return unsupportedSyntax(\"java\", \"assignment expression\", nodeLocation(assignment, filename, source))\n\n    const targetExpression = withParserRanges({\n      kind: /** @type {const} */ (\"IdentifierExpression\"),\n      location: nodeLocation(target, filename, source),\n      name: nodeText(target, source)\n    }, {name: nodeLocation(target, filename, source)})\n\n    return withParserRanges({\n      expression: convertExpression(expression, filename, source),\n      kind: \"AssignmentStatement\",\n      location,\n      target: targetExpression\n    }, {operator: nodeLocation(operator, filename, source)})\n  }\n\n  return unsupportedSyntax(\"java\", statement.name, location)\n}\n\n/**\n * Converts one exhaustive direct Java block child.\n * @param {import(\"@lezer/common\").SyntaxNode} statement - Java statement.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Statement} Semantic statement.\n */\nfunction convertStatement(statement, filename, source) {\n  if (statement.name == \"ReturnStatement\") return convertReturn(statement, filename, source)\n  if (statement.name == \"IfStatement\") return convertIf(statement, filename, source)\n  if (statement.name == \"LocalVariableDeclaration\") return convertLocalStatement(statement, filename, source)\n  if (statement.name == \"ExpressionStatement\") {\n    if (statement.getChild(\"AssignmentExpression\")) return convertLocalStatement(statement, filename, source)\n    if (!statement.getChild(\"MethodInvocation\")) {\n      return unsupportedSyntax(\"java\", statement.name, nodeLocation(statement, filename, source))\n    }\n\n    return convertPrint(statement, filename, source)\n  }\n\n  return unsupportedSyntax(\"java\", statement.name, nodeLocation(statement, filename, source))\n}\n\n/**\n * Converts direct structural children of one Java block in source order.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Java Block node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n */\nfunction convertBlock(node, filename, source) {\n  if (node.name != \"Block\") return unsupportedSyntax(\"java\", `expected block, received ${node.name}`, nodeLocation(node, filename, source))\n\n  return {\n    kind: \"Block\",\n    location: nodeLocation(node, filename, source),\n    statements: structuralChildren(node).map((statement) => convertStatement(statement, filename, source))\n  }\n}\n\n/**\n * Requires an exact Java scalar type node.\n * @param {import(\"@lezer/common\").SyntaxNode | null} sourceType - Java type node.\n * @param {string} subject - Typed subject.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Source location.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").TypeReference} Semantic type.\n */\nfunction convertType(sourceType, subject, location, filename, source) {\n  if (!sourceType) return missingType(\"java\", subject, location)\n  if (![\"PrimitiveType\", \"TypeName\", \"ScopedTypeName\"].includes(sourceType.name)) {\n    return unsupportedSyntax(\"java\", \"unsupported scalar type\", location)\n  }\n\n  const type = sourceScalarType(\"java\", nodeText(sourceType, source), nodeLocation(sourceType, filename, source))\n\n  if (!type) return unsupportedSyntax(\"java\", \"unsupported scalar type\", nodeLocation(sourceType, location.filename, source))\n\n  return type\n}\n\n/**\n * Returns the direct Java declaration type node supported by scalar conversion.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Declaration node.\n * @returns {import(\"@lezer/common\").SyntaxNode | null} Type syntax node.\n */\nfunction declarationType(node) {\n  return node.getChild(\"PrimitiveType\") ?? node.getChild(\"TypeName\") ?? node.getChild(\"ScopedTypeName\")\n}\n\n/**\n * Converts the supported Java function method.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Method declaration.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n */\nfunction convertFunction(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const definition = requiredChild(node, \"Definition\", filename, source)\n  const name = nodeText(definition, source)\n  const parametersNode = requiredChild(node, \"FormalParameters\", filename, source)\n  const parameters = parametersNode.getChildren(\"FormalParameter\").map((parameter) => {\n    const parameterLocation = nodeLocation(parameter, filename, source)\n    const parameterNameNode = requiredChild(parameter, \"Definition\", filename, source)\n    const parameterName = nodeText(parameterNameNode, source)\n\n    const semanticParameter = {\n      kind: /** @type {const} */ (\"Parameter\"),\n      location: parameterLocation,\n      name: parameterName,\n      type: convertType(declarationType(parameter), `Parameter '${parameterName}'`, parameterLocation, filename, source)\n    }\n\n    return withParserRanges(semanticParameter, {name: nodeLocation(parameterNameNode, filename, source)})\n  })\n  const block = requiredChild(node, \"Block\", filename, source)\n  const body = convertBlock(block, filename, source)\n\n  return withParserRanges({\n    body,\n    kind: \"FunctionDeclaration\",\n    location,\n    name,\n    parameters,\n    returnType: convertType(declarationType(node), `Function '${name}' return`, location, filename, source)\n  }, {name: nodeLocation(definition, filename, source)})\n}\n\n/**\n * Converts the existing exact Java if/else terminal with restricted branch prefixes.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Java if statement.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").IfStatement} Semantic branch.\n */\nfunction convertIf(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const conditionContainer = requiredChild(node, \"ParenthesizedExpression\", filename, source)\n  const conditionNodes = structuralChildren(conditionContainer)\n  const condition = conditionNodes.length == 1 ? conditionNodes[0] : undefined\n  const direct = directChildren(node)\n  const conditionIndex = direct.findIndex((child) => child.name == conditionContainer.name &&\n    child.from == conditionContainer.from && child.to == conditionContainer.to)\n  const consequentNode = direct[conditionIndex + 1]\n  const alternateNode = direct.at(-1) == consequentNode ? undefined : direct.at(-1)\n\n  if (!condition || !consequentNode || consequentNode.name != \"Block\") {\n    return unsupportedSyntax(\"java\", \"if without block consequent\", location)\n  }\n\n  let alternate\n\n  if (alternateNode?.name == \"Block\") alternate = convertBlock(alternateNode, filename, source)\n  else if (alternateNode?.name == \"IfStatement\") {\n    alternate = {\n      kind: /** @type {const} */ (\"Block\"),\n      location: nodeLocation(alternateNode, filename, source),\n      statements: [convertIf(alternateNode, filename, source)]\n    }\n  } else if (alternateNode && alternateNode.name != \"else\") {\n    return unsupportedSyntax(\"java\", `if alternate ${alternateNode.name}`, nodeLocation(alternateNode, filename, source))\n  }\n\n  return {\n    ...(alternate ? {alternate} : {}),\n    condition: convertExpression(condition, filename, source),\n    consequent: convertBlock(consequentNode, filename, source),\n    kind: \"IfStatement\",\n    location\n  }\n}\n\n/**\n * Converts Java's supported main method.\n * @param {import(\"@lezer/common\").SyntaxNode} node - Main method.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").EntryPoint} Semantic entry point.\n */\nfunction convertEntryPoint(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const block = requiredChild(node, \"Block\", filename, source)\n  const body = convertBlock(block, filename, source)\n\n  return {body, kind: \"EntryPoint\", location}\n}\n\n/**\n * Converts one supported Java print statement.\n * @param {import(\"@lezer/common\").SyntaxNode} statement - Expression statement.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").PrintStatement} Semantic print.\n */\nfunction convertPrint(statement, filename, source) {\n  const location = nodeLocation(statement, filename, source)\n\n  const printInvocation = statement.getChild(\"MethodInvocation\")\n\n  if (!printInvocation) return unsupportedSyntax(\"java\", \"main without System.out.println\", location)\n\n  const fieldAccess = printInvocation.getChild(\"FieldAccess\")\n  const methodName = printInvocation.getChild(\"MethodName\")\n\n  if (!fieldAccess || !methodName || nodeText(fieldAccess, source) != \"System.out\" || nodeText(methodName, source) != \"println\") {\n    return unsupportedSyntax(\"java\", \"main without System.out.println\", nodeLocation(printInvocation, filename, source))\n  }\n\n  const argumentList = requiredChild(printInvocation, \"ArgumentList\", filename, source)\n  const arguments_ = structuralChildren(argumentList)\n\n  if (arguments_.length != 1) {\n    return unsupportedSyntax(\"java\", \"println without one supported argument\", nodeLocation(argumentList, filename, source))\n  }\n\n  const printLocation = nodeLocation(printInvocation, filename, source)\n\n  return {expression: convertExpression(arguments_[0], filename, source), kind: \"PrintStatement\", location: printLocation}\n}\n\n/**\n * Parses Java into the shared semantic module.\n * @param {object} input - Parser input.\n * @param {string} input.filename - Source filename.\n * @param {string} input.source - Source text.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parseJava({filename, source}) {\n  const tree = parser.parse(source)\n  const error = descendants(tree.topNode, \"⚠\")[0]\n\n  if (error) {\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\",\n      language: \"java\",\n      location: nodeLocation(error, filename, source),\n      message: \"Java parser reported invalid syntax.\"\n    })\n  }\n\n  const methods = descendants(tree.topNode, \"MethodDeclaration\")\n  const mainMethod = methods.find((method) => nodeText(requiredChild(method, \"Definition\", filename, source), source) == \"main\")\n  const functionMethods = methods.filter((method) => method != mainMethod)\n  const location = moduleLocation(filename, source)\n\n  if (functionMethods.length == 0) return unsupportedSyntax(\"java\", \"class without a semantic function\", location)\n  if (!mainMethod) return unsupportedSyntax(\"java\", \"class without main\", location)\n\n  const functions = functionMethods.map((method) => convertFunction(method, filename, source))\n  const entryPoint = convertEntryPoint(mainMethod, filename, source)\n\n  return {entryPoint, functions, kind: \"Module\", location}\n}\n"]}