semantifold 0.1.1 → 0.3.0

package/build/src/frontends/go.js

@@ -0,0 +1,712 @@
+// @ts-check
+import Parser from "tree-sitter";
+import GoLanguage from "tree-sitter-go/bindings/node/index.js";
+import { missingType, parseFailure, 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} */(GoLanguage)));
+const immutableMarker = "// @semantifold-immutable";
+const goKeywords = new Set([
+    "break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", "chan",
+    "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue",
+    "for", "import", "return", "var"
+]);
+const functionReserved = new Set(["main", "init", "fmt", "int64", "bool", "string", "true", "false"]);
+const bindingReserved = new Set(["fmt", "int64", "bool", "string", "true", "false"]);
+const binaryOperations = new Map([
+    ["+", "Add"], ["-", "Subtract"], ["*", "Multiply"], ["==", "Equal"], ["!=", "NotEqual"],
+    ["<", "LessThan"], ["<=", "LessThanOrEqual"], [">", "GreaterThan"], [">=", "GreaterThanOrEqual"],
+    ["&&", "And"], ["||", "Or"]
+]);
+/** @typedef {{comments: import("tree-sitter").SyntaxNode[], usedMarkers: Set<import("tree-sitter").SyntaxNode>, assignmentTargets: Set<string>}} GoContext */
+/**
+ * Verifies one binding UTF-16 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;
+}
+/**
+ * Converts one CST range.
+ * @param {import("tree-sitter").SyntaxNode} node CST node.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Exact location.
+ */
+function nodeLocation(node, filename, source) {
+    return locationFromOffsets(filename, source, bindingIndexToUtf16Offset(source, node.startIndex), bindingIndexToUtf16Offset(source, node.endIndex));
+}
+/**
+ * Requires one grammar field.
+ * @param {import("tree-sitter").SyntaxNode} node Field owner.
+ * @param {string} field Field name.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("tree-sitter").SyntaxNode} Required child.
+ */
+function requiredField(node, field, filename, source) {
+    const child = node.childForFieldName(field);
+    if (!child)
+        return unsupportedSyntax("go", node.type + " without " + field, nodeLocation(node, filename, source));
+    return child;
+}
+/**
+ * Traverses every named and anonymous node before conversion.
+ * @param {import("tree-sitter").SyntaxNode} node Current node.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {void}
+ */
+function validateParserTree(node, filename, source) {
+    if (node.hasError || node.isError || node.isMissing) {
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR",
+            language: "go",
+            location: nodeLocation(node, filename, source),
+            message: "Tree-sitter exposed recovery at '" + node.type + "'."
+        });
+    }
+    if (!node.isNamed && node.type == ";") {
+        return unsupportedSyntax("go", "explicit semicolon", nodeLocation(node, filename, source));
+    }
+    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 + ".");
+        validateParserTree(child, filename, source);
+    }
+}
+/**
+ * Selects semantic children while retaining comments for metadata validation.
+ * @param {import("tree-sitter").SyntaxNode} node Parent node.
+ * @returns {import("tree-sitter").SyntaxNode[]} Non-comment named children.
+ */
+function semanticChildren(node) {
+    return node.namedChildren.filter((child) => child.type != "comment");
+}
+/**
+ * Validates one Go identifier.
+ * @param {import("tree-sitter").SyntaxNode} node Identifier node.
+ * @param {"function" | "parameter" | "local" | "assignment target" | "reference" | "callee"} role Identifier role.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {string} Accepted spelling.
+ */
+function identifier(node, role, filename, source) {
+    const name = node.text;
+    const reserved = ["function", "callee"].includes(role) ? functionReserved : ["parameter", "local", "assignment target"].includes(role)
+        ? bindingReserved
+        : new Set();
+    if (node.type != "identifier" || !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name) || name == "_" ||
+        goKeywords.has(name) || reserved.has(name)) {
+        return unsupportedSyntax("go", role + " identifier '" + name + "'", nodeLocation(node, filename, source));
+    }
+    return name;
+}
+/**
+ * Converts an explicit scalar.
+ * @param {import("tree-sitter").SyntaxNode | null} node Type node.
+ * @param {string} subject Diagnostic subject.
+ * @param {import("../semantic/types.js").SourceLocation} ownerLocation Owner location.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").TypeReference} Semantic type.
+ */
+function convertType(node, subject, ownerLocation, filename, source) {
+    if (!node)
+        return missingType("go", subject, ownerLocation);
+    const location = nodeLocation(node, filename, source);
+    const type = sourceScalarType("go", node.text, location);
+    if (!type || node.type != "type_identifier") {
+        return unsupportedSyntax("go", "unsupported scalar type '" + node.text + "'", location);
+    }
+    return type;
+}
+/**
+ * Finds exactly one accepted operator token.
+ * @param {import("tree-sitter").SyntaxNode} node Operation node.
+ * @param {Set<string>} spellings Accepted spellings.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("tree-sitter").SyntaxNode} Operator token.
+ */
+function operatorToken(node, spellings, filename, source) {
+    const field = node.childForFieldName("operator");
+    const candidates = field ? [field] : node.children.filter((child) => !child.isNamed && spellings.has(child.type));
+    if (candidates.length != 1 || !spellings.has(candidates[0].type)) {
+        return unsupportedSyntax("go", node.type + " operator", nodeLocation(node, filename, source));
+    }
+    return candidates[0];
+}
+/**
+ * Requires one expression in an expression list.
+ * @param {import("tree-sitter").SyntaxNode} node Expression list.
+ * @param {string} subject Diagnostic subject.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("tree-sitter").SyntaxNode} Sole expression.
+ */
+function soleExpression(node, subject, filename, source) {
+    const children = semanticChildren(node);
+    if (node.type != "expression_list" || children.length != 1) {
+        return unsupportedSyntax("go", subject, nodeLocation(node, filename, source));
+    }
+    return children[0];
+}
+/**
+ * Converts one expression.
+ * @param {import("tree-sitter").SyntaxNode} node Expression node.
+ * @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.type == "parenthesized_expression") {
+        const children = semanticChildren(node);
+        if (children.length != 1)
+            return unsupportedSyntax("go", node.type, location);
+        return convertExpression(children[0], filename, source);
+    }
+    if (node.type == "identifier") {
+        const name = identifier(node, "reference", filename, source);
+        return withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location, name }, { name: location });
+    }
+    if (node.type == "int_literal") {
+        if (!/^(?:0|[1-9][0-9]*)$/u.test(node.text))
+            return unsupportedSyntax("go", "noncanonical integer literal", location);
+        const value = Number(BigInt(node.text));
+        if (!Number.isSafeInteger(value))
+            return unsupportedSyntax("go", "non-safe integer literal", location);
+        return withParserRanges({ kind: /** @type {const} */ ("IntegerLiteral"), location, value }, { literal: location });
+    }
+    if (node.type == "true" || node.type == "false") {
+        return withParserRanges({ kind: /** @type {const} */ ("BooleanLiteral"), location, value: node.type == "true" }, { literal: location });
+    }
+    if (node.type == "interpreted_string_literal") {
+        return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: decodeString(node, filename, source) }, {
+            literal: location
+        });
+    }
+    if (node.type == "unary_expression") {
+        const operand = requiredField(node, "operand", filename, source);
+        const operator = operatorToken(node, new Set(["!", "-"]), filename, source);
+        if (semanticChildren(node).length != 1)
+            return unsupportedSyntax("go", "unary expression shape", location);
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand: convertExpression(operand, filename, source)
+        }, { operator: nodeLocation(operator, filename, source) }), operator.type == "!" ? "Not" : "Negate")));
+    }
+    if (node.type == "binary_expression") {
+        const left = requiredField(node, "left", filename, source);
+        const right = requiredField(node, "right", filename, source);
+        const operator = operatorToken(node, new Set(binaryOperations.keys()), filename, source);
+        const adapted = binaryOperations.get(operator.type);
+        if (!adapted || semanticChildren(node).length != 2)
+            return unsupportedSyntax("go", "binary expression shape", location);
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression",
+            left: convertExpression(left, filename, source),
+            location,
+            right: convertExpression(right, filename, source)
+        }, { operator: nodeLocation(operator, filename, source) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (adapted))));
+    }
+    if (node.type == "call_expression") {
+        const calleeNode = requiredField(node, "function", filename, source);
+        const argumentsNode = requiredField(node, "arguments", filename, source);
+        if (calleeNode.type != "identifier" || argumentsNode.type != "argument_list" || semanticChildren(node).length != 2) {
+            return unsupportedSyntax("go", "qualified or dynamic call", location);
+        }
+        const callee = identifier(calleeNode, "callee", filename, source);
+        const arguments_ = semanticChildren(argumentsNode).map((argument) => convertExpression(argument, filename, source));
+        return withParserRanges({ arguments: arguments_, callee, kind: /** @type {const} */ ("CallExpression"), location }, {
+            callee: nodeLocation(calleeNode, filename, source)
+        });
+    }
+    return unsupportedSyntax("go", node.type, location);
+}
+/**
+ * Decodes an interpreted Go string to valid Unicode scalar text.
+ * @param {import("tree-sitter").SyntaxNode} node Literal node.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {string} Decoded value.
+ */
+function decodeString(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const text = node.text;
+    if (!text.startsWith('"') || !text.endsWith('"') || /[\r\n]/u.test(text)) {
+        return unsupportedSyntax("go", "noncanonical interpreted string literal", location);
+    }
+    /** @type {number[]} */
+    const bytes = [];
+    /**
+     * Appends one UTF-8 text segment.
+     * @param {string} value Text segment.
+     * @returns {number} New byte length.
+     */
+    const appendText = (value) => bytes.push(...new TextEncoder().encode(value));
+    const simple = new Map([
+        ["a", 7], ["b", 8], ["f", 12], ["n", 10], ["r", 13], ["t", 9], ["v", 11], ["\\", 92], ['"', 34]
+    ]);
+    for (let index = 1; index < text.length - 1; index += 1) {
+        const character = text[index];
+        if (character != "\\") {
+            const codePoint = text.codePointAt(index);
+            if (codePoint === undefined)
+                return unsupportedSyntax("go", "invalid string literal", location);
+            appendText(String.fromCodePoint(codePoint));
+            if (codePoint > 0xFFFF)
+                index += 1;
+            continue;
+        }
+        const escape = text[++index];
+        if (escape === undefined)
+            return unsupportedSyntax("go", "invalid string escape", location);
+        if (simple.has(escape)) {
+            bytes.push(/** @type {number} */ (simple.get(escape)));
+            continue;
+        }
+        if (escape == "x") {
+            const digits = text.slice(index + 1, index + 3);
+            if (!/^[0-9A-Fa-f]{2}$/u.test(digits))
+                return unsupportedSyntax("go", "invalid byte escape", location);
+            bytes.push(Number.parseInt(digits, 16));
+            index += 2;
+            continue;
+        }
+        if (/[0-7]/u.test(escape)) {
+            const digits = text.slice(index, index + 3);
+            if (!/^[0-7]{3}$/u.test(digits))
+                return unsupportedSyntax("go", "invalid octal escape", location);
+            const value = Number.parseInt(digits, 8);
+            if (value > 255)
+                return unsupportedSyntax("go", "octal escape outside byte range", location);
+            bytes.push(value);
+            index += 2;
+            continue;
+        }
+        const width = escape == "u" ? 4 : escape == "U" ? 8 : 0;
+        const digits = text.slice(index + 1, index + 1 + width);
+        if (!width || digits.length != width || !/^[0-9A-Fa-f]+$/u.test(digits)) {
+            return unsupportedSyntax("go", "unsupported string escape", location);
+        }
+        const value = Number.parseInt(digits, 16);
+        if (value > 0x10FFFF || value >= 0xD800 && value <= 0xDFFF) {
+            return unsupportedSyntax("go", "invalid Unicode string escape", location);
+        }
+        appendText(String.fromCodePoint(value));
+        index += width;
+    }
+    let decoded;
+    try {
+        decoded = new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(bytes));
+    }
+    catch {
+        return unsupportedSyntax("go", "string byte escapes do not form valid UTF-8", location);
+    }
+    if (!hasOnlyUnicodeScalars(decoded))
+        return unsupportedSyntax("go", "invalid Unicode string literal", location);
+    return decoded;
+}
+/**
+ * Collects plain assignment targets in one root function.
+ * @param {import("tree-sitter").SyntaxNode} body Root body.
+ * @returns {Set<string>} Assigned names.
+ */
+function collectAssignmentTargets(body) {
+    const names = new Set();
+    for (const assignment of body.descendantsOfType("assignment_statement")) {
+        const left = assignment.childForFieldName("left");
+        const children = left ? semanticChildren(left) : [];
+        if (left?.type == "expression_list" && children.length == 1 && children[0].type == "identifier") {
+            names.add(children[0].text);
+        }
+    }
+    return names;
+}
+/**
+ * Claims an exact adjacent immutable marker.
+ * @param {import("tree-sitter").SyntaxNode} node Local declaration.
+ * @param {GoContext} context Comment context.
+ * @returns {boolean} Whether marked immutable.
+ */
+function takeImmutableMarker(node, context) {
+    const marker = context.comments.find((comment) => comment.text == immutableMarker &&
+        comment.endPosition.row + 1 == node.startPosition.row && comment.startPosition.column == node.startPosition.column);
+    if (!marker)
+        return false;
+    context.usedMarkers.add(marker);
+    return true;
+}
+/**
+ * Converts one exact initialized local.
+ * @param {import("tree-sitter").SyntaxNode} node Declaration node.
+ * @param {GoContext} context Function context.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").LocalDeclaration} Semantic local.
+ */
+function convertLocal(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const children = semanticChildren(node);
+    if (children.length != 1 || children[0].type != "var_spec")
+        return unsupportedSyntax("go", "local declaration shape", location);
+    const spec = children[0];
+    const nameNode = requiredField(spec, "name", filename, source);
+    const typeNode = spec.childForFieldName("type");
+    const valueNode = requiredField(spec, "value", filename, source);
+    if (semanticChildren(spec).length != (typeNode ? 3 : 2))
+        return unsupportedSyntax("go", "local declaration shape", location);
+    const expressionNode = soleExpression(valueNode, "local initializer count", filename, source);
+    const name = identifier(nameNode, "local", filename, source);
+    const markedImmutable = takeImmutableMarker(node, context);
+    const operator = operatorToken(spec, new Set(["="]), filename, source);
+    return withParserRanges({
+        initializer: convertExpression(expressionNode, filename, source),
+        kind: /** @type {const} */ ("LocalDeclaration"),
+        location,
+        mutable: !markedImmutable && context.assignmentTargets.has(name),
+        name,
+        type: convertType(typeNode, "Local '" + name + "'", location, filename, source)
+    }, { name: nodeLocation(nameNode, filename, source), operator: nodeLocation(operator, filename, source) });
+}
+/**
+ * Converts one plain assignment.
+ * @param {import("tree-sitter").SyntaxNode} node Assignment node.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").AssignmentStatement} Semantic assignment.
+ */
+function convertAssignment(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const leftList = requiredField(node, "left", filename, source);
+    const rightList = requiredField(node, "right", filename, source);
+    const operator = operatorToken(node, new Set(["="]), filename, source);
+    const left = soleExpression(leftList, "assignment target count", filename, source);
+    const right = soleExpression(rightList, "assignment value count", filename, source);
+    if (left.type != "identifier" || semanticChildren(node).length != 2) {
+        return unsupportedSyntax("go", "assignment shape", location);
+    }
+    const name = identifier(left, "assignment target", filename, source);
+    const nameLocation = nodeLocation(left, filename, source);
+    return withParserRanges({
+        expression: convertExpression(right, filename, source),
+        kind: /** @type {const} */ ("AssignmentStatement"),
+        location,
+        target: withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: nameLocation, name }, { name: nameLocation })
+    }, { operator: nodeLocation(operator, filename, source) });
+}
+/**
+ * Recognizes exact fmt.Println.
+ * @param {import("tree-sitter").SyntaxNode} node Candidate selector.
+ * @returns {boolean} Exact print receiver.
+ */
+function isPrintReceiver(node) {
+    return node.type == "selector_expression" && semanticChildren(node).length == 2 &&
+        node.childForFieldName("operand")?.type == "identifier" && node.childForFieldName("operand")?.text == "fmt" &&
+        node.childForFieldName("field")?.type == "field_identifier" && node.childForFieldName("field")?.text == "Println";
+}
+/**
+ * Converts one print expression statement.
+ * @param {import("tree-sitter").SyntaxNode} node Expression statement.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").PrintStatement} Semantic print.
+ */
+function convertPrint(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const children = semanticChildren(node);
+    if (children.length != 1 || children[0].type != "call_expression") {
+        return unsupportedSyntax("go", "expression statement other than print", location);
+    }
+    const call = children[0];
+    const callee = requiredField(call, "function", filename, source);
+    const argumentsNode = requiredField(call, "arguments", filename, source);
+    const arguments_ = semanticChildren(argumentsNode);
+    if (!isPrintReceiver(callee) || semanticChildren(call).length != 2 || argumentsNode.type != "argument_list" ||
+        arguments_.length != 1) {
+        return unsupportedSyntax("go", "print call shape", nodeLocation(call, filename, source));
+    }
+    return { expression: convertExpression(arguments_[0], filename, source), kind: /** @type {const} */ ("PrintStatement"), location };
+}
+/**
+ * Converts one conditional.
+ * @param {import("tree-sitter").SyntaxNode} node If node.
+ * @param {GoContext} context Function context.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").IfStatement} Semantic conditional.
+ */
+function convertIf(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const condition = requiredField(node, "condition", filename, source);
+    const consequence = requiredField(node, "consequence", filename, source);
+    const alternative = node.childForFieldName("alternative");
+    const expectedChildren = alternative ? 3 : 2;
+    if (semanticChildren(node).length != expectedChildren)
+        return unsupportedSyntax("go", "if initializer or shape", location);
+    return {
+        ...(alternative ? { alternate: alternative.type == "if_statement"
+                ? { kind: /** @type {const} */ ("Block"), location: nodeLocation(alternative, filename, source),
+                    statements: [convertIf(alternative, context, filename, source)] }
+                : convertBlock(alternative, context, filename, source) } : {}),
+        condition: convertExpression(condition, filename, source),
+        consequent: convertBlock(consequence, context, filename, source),
+        kind: /** @type {const} */ ("IfStatement"),
+        location
+    };
+}
+/**
+ * Converts one supported statement.
+ * @param {import("tree-sitter").SyntaxNode} node Statement node.
+ * @param {GoContext} context Function context.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").Statement} Semantic statement.
+ */
+function convertStatement(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type == "var_declaration")
+        return convertLocal(node, context, filename, source);
+    if (node.type == "assignment_statement")
+        return convertAssignment(node, filename, source);
+    if (node.type == "if_statement")
+        return convertIf(node, context, filename, source);
+    if (node.type == "expression_statement")
+        return convertPrint(node, filename, source);
+    if (node.type == "return_statement") {
+        const children = semanticChildren(node);
+        if (children.length != 1)
+            return unsupportedSyntax("go", "return without one expression", location);
+        return {
+            expression: convertExpression(soleExpression(children[0], "return expression count", filename, source), filename, source),
+            kind: /** @type {const} */ ("ReturnStatement"),
+            location
+        };
+    }
+    return unsupportedSyntax("go", node.type, location);
+}
+/**
+ * Converts one lexical block.
+ * @param {import("tree-sitter").SyntaxNode} node Block node.
+ * @param {GoContext} context Function context.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").Block} Semantic block.
+ */
+function convertBlock(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const children = semanticChildren(node);
+    if (node.type != "block" || children.length > 1 || children[0]?.type != "statement_list") {
+        if (!(node.type == "block" && children.length == 0))
+            return unsupportedSyntax("go", "block shape", location);
+    }
+    const statements = children.length == 0 ? [] : semanticChildren(children[0]);
+    return { kind: /** @type {const} */ ("Block"), location,
+        statements: statements.map((statement) => convertStatement(statement, context, filename, source)) };
+}
+/**
+ * Converts one parameter.
+ * @param {import("tree-sitter").SyntaxNode} node Parameter node.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").Parameter} Semantic parameter.
+ */
+function convertParameter(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const nameNode = requiredField(node, "name", filename, source);
+    const typeNode = node.childForFieldName("type");
+    if (node.type != "parameter_declaration" || semanticChildren(node).length != 2) {
+        return unsupportedSyntax("go", "parameter shape", location);
+    }
+    const name = identifier(nameNode, "parameter", filename, source);
+    return withParserRanges({
+        kind: /** @type {const} */ ("Parameter"),
+        location,
+        name,
+        type: convertType(typeNode, "Parameter '" + name + "'", location, filename, source)
+    }, { name: nodeLocation(nameNode, filename, source) });
+}
+/**
+ * Converts one semantic function.
+ * @param {import("tree-sitter").SyntaxNode} node Function node.
+ * @param {GoContext} baseContext File context.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+ */
+function convertFunction(node, baseContext, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const nameNode = requiredField(node, "name", filename, source);
+    const parametersNode = requiredField(node, "parameters", filename, source);
+    const resultNode = node.childForFieldName("result");
+    const bodyNode = requiredField(node, "body", filename, source);
+    if (node.type != "function_declaration" || semanticChildren(node).length != (resultNode ? 4 : 3) ||
+        node.childForFieldName("receiver") || node.childForFieldName("type_parameters")) {
+        return unsupportedSyntax("go", "function declaration shape", location);
+    }
+    const name = identifier(nameNode, "function", filename, source);
+    const parameterNodes = semanticChildren(parametersNode);
+    if (parameterNodes.length != 2 || parameterNodes.some((parameter) => parameter.type != "parameter_declaration")) {
+        return unsupportedSyntax("go", "function parameter count or shape", nodeLocation(parametersNode, filename, source));
+    }
+    const context = { ...baseContext, assignmentTargets: collectAssignmentTargets(bodyNode) };
+    return withParserRanges({
+        body: convertBlock(bodyNode, context, filename, source),
+        kind: /** @type {const} */ ("FunctionDeclaration"),
+        location,
+        name,
+        parameters: parameterNodes.map((parameter) => convertParameter(parameter, filename, source)),
+        returnType: convertType(resultNode, "Function '" + name + "' return", location, filename, source)
+    }, { name: nodeLocation(nameNode, filename, source) });
+}
+/**
+ * Converts the exact final func main() entry.
+ * @param {import("tree-sitter").SyntaxNode} node Main node.
+ * @param {GoContext} baseContext File context.
+ * @param {string} filename Source filename.
+ * @param {string} source Complete source.
+ * @returns {import("../semantic/types.js").EntryPoint} Semantic entry.
+ */
+function convertMain(node, baseContext, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const name = requiredField(node, "name", filename, source);
+    const parameters = requiredField(node, "parameters", filename, source);
+    const body = requiredField(node, "body", filename, source);
+    if (semanticChildren(node).length != 3 || name.text != "main" || semanticChildren(parameters).length != 0 ||
+        node.childForFieldName("result") || node.childForFieldName("receiver") || node.childForFieldName("type_parameters")) {
+        return unsupportedSyntax("go", "main scaffolding", location);
+    }
+    const context = { ...baseContext, assignmentTargets: collectAssignmentTargets(body) };
+    return { body: convertBlock(body, context, filename, source), kind: /** @type {const} */ ("EntryPoint"), location };
+}
+/**
+ * Reports whether any print exists.
+ * @param {import("../semantic/types.js").SemanticModule} module Module.
+ * @returns {boolean} Print presence.
+ */
+function hasPrint(module) {
+    /**
+     * Reports whether one nested block prints.
+     * @type {(block: import("../semantic/types.js").Block) => boolean}
+     */
+    const blockHasPrint = (block) => block.statements.some((statement) => statement.kind == "PrintStatement" ||
+        statement.kind == "IfStatement" && (blockHasPrint(statement.consequent) || Boolean(statement.alternate && blockHasPrint(statement.alternate))));
+    return module.functions.some(({ body }) => blockHasPrint(body)) || blockHasPrint(module.entryPoint.body);
+}
+/**
+ * Parses the strict Task 024 Go profile.
+ * @param {{filename: string, source: string}} input Parser input.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parseGo({ filename, source }) {
+    if (!hasOnlyUnicodeScalars(source)) {
+        const offset = firstLoneSurrogateOffset(source);
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR",
+            language: "go",
+            location: locationFromOffsets(filename, source, offset, offset + 1),
+            message: "Go source contains an invalid lone UTF-16 surrogate."
+        });
+    }
+    let tree;
+    try {
+        tree = parser.parse(source);
+    }
+    catch (error) {
+        return parseFailure("go", error);
+    }
+    const root = tree.rootNode;
+    validateParserTree(root, filename, source);
+    if (root.type != "source_file")
+        throw new Error("Tree-sitter returned Go root '" + root.type + "'.");
+    const location = moduleLocation(filename, source);
+    const comments = root.descendantsOfType("comment");
+    for (const comment of comments) {
+        if (/^\/\/go:/u.test(comment.text) || /^\/\/ \+build(?:\s|$)/u.test(comment.text) ||
+            /^\/\/line(?:\s|$)/u.test(comment.text) || /^\/\*line(?:\s|$)/u.test(comment.text)) {
+            return unsupportedSyntax("go", "source directive", nodeLocation(comment, filename, source));
+        }
+        if (comment.text.includes("@semantifold") && comment.text != immutableMarker) {
+            return unsupportedSyntax("go", "invalid Semantifold metadata comment", nodeLocation(comment, filename, source));
+        }
+    }
+    const children = semanticChildren(root);
+    if (children.length < 3 || children[0].type != "package_clause") {
+        return unsupportedSyntax("go", "compilation-unit scaffolding", location);
+    }
+    const packageChildren = semanticChildren(children[0]);
+    if (packageChildren.length != 1 || packageChildren[0].type != "package_identifier" || packageChildren[0].text != "main") {
+        return unsupportedSyntax("go", "package main scaffolding", nodeLocation(children[0], filename, source));
+    }
+    let memberStart = 1;
+    let hasFmtImport = false;
+    if (children[1]?.type == "import_declaration") {
+        const declaration = children[1];
+        const imports = semanticChildren(declaration);
+        if (imports.length != 1 || imports[0].type != "import_spec" || semanticChildren(imports[0]).length != 1 ||
+            imports[0].childForFieldName("path")?.type != "interpreted_string_literal" ||
+            imports[0].childForFieldName("path")?.text != '"fmt"') {
+            return unsupportedSyntax("go", "fmt import scaffolding", nodeLocation(declaration, filename, source));
+        }
+        hasFmtImport = true;
+        memberStart = 2;
+    }
+    const members = children.slice(memberStart);
+    if (members.length < 2 || members.some((member) => member.type != "function_declaration")) {
+        return unsupportedSyntax("go", "top-level declarations", location);
+    }
+    const mainNodes = members.filter((member) => member.childForFieldName("name")?.text == "main");
+    if (mainNodes.length != 1 || members.at(-1)?.id != mainNodes[0].id) {
+        return unsupportedSyntax("go", "main ordering", location);
+    }
+    const baseContext = { assignmentTargets: new Set(), comments, usedMarkers: new Set() };
+    const module = {
+        entryPoint: convertMain(mainNodes[0], baseContext, filename, source),
+        functions: members.slice(0, -1).map((member) => convertFunction(member, baseContext, filename, source)),
+        kind: /** @type {const} */ ("Module"),
+        location
+    };
+    const invalidMarker = comments.find((comment) => comment.text == immutableMarker && !baseContext.usedMarkers.has(comment));
+    if (invalidMarker)
+        return unsupportedSyntax("go", "unattached immutable marker", nodeLocation(invalidMarker, filename, source));
+    if (hasFmtImport != hasPrint(module))
+        return unsupportedSyntax("go", "fmt import and print usage mismatch", location);
+    validateParsedModule(module, "go");
+    return module;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"go.js","sourceRoot":"","sources":["../../../src/frontends/go.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Parser from \"tree-sitter\"\nimport GoLanguage from \"tree-sitter-go/bindings/node/index.js\"\nimport {missingType, parseFailure, 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} */ (GoLanguage)))\n\nconst immutableMarker = \"// @semantifold-immutable\"\nconst goKeywords = new Set([\n  \"break\", \"default\", \"func\", \"interface\", \"select\", \"case\", \"defer\", \"go\", \"map\", \"struct\", \"chan\",\n  \"else\", \"goto\", \"package\", \"switch\", \"const\", \"fallthrough\", \"if\", \"range\", \"type\", \"continue\",\n  \"for\", \"import\", \"return\", \"var\"\n])\nconst functionReserved = new Set([\"main\", \"init\", \"fmt\", \"int64\", \"bool\", \"string\", \"true\", \"false\"])\nconst bindingReserved = new Set([\"fmt\", \"int64\", \"bool\", \"string\", \"true\", \"false\"])\nconst binaryOperations = new Map([\n  [\"+\", \"Add\"], [\"-\", \"Subtract\"], [\"*\", \"Multiply\"], [\"==\", \"Equal\"], [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"], [\"<=\", \"LessThanOrEqual\"], [\">\", \"GreaterThan\"], [\">=\", \"GreaterThanOrEqual\"],\n  [\"&&\", \"And\"], [\"||\", \"Or\"]\n])\n\n/** @typedef {{comments: import(\"tree-sitter\").SyntaxNode[], usedMarkers: Set<import(\"tree-sitter\").SyntaxNode>, assignmentTargets: Set<string>}} GoContext */\n\n/**\n * Verifies one binding UTF-16 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/**\n * Converts one CST range.\n * @param {import(\"tree-sitter\").SyntaxNode} node CST node.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Exact location.\n */\nfunction nodeLocation(node, filename, source) {\n  return locationFromOffsets(filename, source, bindingIndexToUtf16Offset(source, node.startIndex),\n    bindingIndexToUtf16Offset(source, node.endIndex))\n}\n\n/**\n * Requires one grammar field.\n * @param {import(\"tree-sitter\").SyntaxNode} node Field owner.\n * @param {string} field Field name.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"tree-sitter\").SyntaxNode} Required child.\n */\nfunction requiredField(node, field, filename, source) {\n  const child = node.childForFieldName(field)\n\n  if (!child) return unsupportedSyntax(\"go\", node.type + \" without \" + field, nodeLocation(node, filename, source))\n  return child\n}\n\n/**\n * Traverses every named and anonymous node before conversion.\n * @param {import(\"tree-sitter\").SyntaxNode} node Current node.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {void}\n */\nfunction validateParserTree(node, filename, source) {\n  if (node.hasError || node.isError || node.isMissing) {\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\",\n      language: \"go\",\n      location: nodeLocation(node, filename, source),\n      message: \"Tree-sitter exposed recovery at '\" + node.type + \"'.\"\n    })\n  }\n  if (!node.isNamed && node.type == \";\") {\n    return unsupportedSyntax(\"go\", \"explicit semicolon\", nodeLocation(node, filename, source))\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    validateParserTree(child, filename, source)\n  }\n}\n\n/**\n * Selects semantic children while retaining comments for metadata validation.\n * @param {import(\"tree-sitter\").SyntaxNode} node Parent node.\n * @returns {import(\"tree-sitter\").SyntaxNode[]} Non-comment named children.\n */\nfunction semanticChildren(node) {\n  return node.namedChildren.filter((child) => child.type != \"comment\")\n}\n\n/**\n * Validates one Go identifier.\n * @param {import(\"tree-sitter\").SyntaxNode} node Identifier node.\n * @param {\"function\" | \"parameter\" | \"local\" | \"assignment target\" | \"reference\" | \"callee\"} role Identifier role.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {string} Accepted spelling.\n */\nfunction identifier(node, role, filename, source) {\n  const name = node.text\n  const reserved = [\"function\", \"callee\"].includes(role) ? functionReserved : [\"parameter\", \"local\", \"assignment target\"].includes(role)\n    ? bindingReserved\n    : new Set()\n\n  if (node.type != \"identifier\" || !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name) || name == \"_\" ||\n    goKeywords.has(name) || reserved.has(name)) {\n    return unsupportedSyntax(\"go\", role + \" identifier '\" + name + \"'\", nodeLocation(node, filename, source))\n  }\n  return name\n}\n\n/**\n * Converts an explicit scalar.\n * @param {import(\"tree-sitter\").SyntaxNode | null} node Type node.\n * @param {string} subject Diagnostic subject.\n * @param {import(\"../semantic/types.js\").SourceLocation} ownerLocation Owner 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(node, subject, ownerLocation, filename, source) {\n  if (!node) return missingType(\"go\", subject, ownerLocation)\n  const location = nodeLocation(node, filename, source)\n  const type = sourceScalarType(\"go\", node.text, location)\n\n  if (!type || node.type != \"type_identifier\") {\n    return unsupportedSyntax(\"go\", \"unsupported scalar type '\" + node.text + \"'\", location)\n  }\n  return type\n}\n\n/**\n * Finds exactly one accepted operator token.\n * @param {import(\"tree-sitter\").SyntaxNode} node Operation node.\n * @param {Set<string>} spellings Accepted spellings.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"tree-sitter\").SyntaxNode} Operator token.\n */\nfunction operatorToken(node, spellings, filename, source) {\n  const field = node.childForFieldName(\"operator\")\n  const candidates = field ? [field] : node.children.filter((child) => !child.isNamed && spellings.has(child.type))\n\n  if (candidates.length != 1 || !spellings.has(candidates[0].type)) {\n    return unsupportedSyntax(\"go\", node.type + \" operator\", nodeLocation(node, filename, source))\n  }\n  return candidates[0]\n}\n\n/**\n * Requires one expression in an expression list.\n * @param {import(\"tree-sitter\").SyntaxNode} node Expression list.\n * @param {string} subject Diagnostic subject.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"tree-sitter\").SyntaxNode} Sole expression.\n */\nfunction soleExpression(node, subject, filename, source) {\n  const children = semanticChildren(node)\n\n  if (node.type != \"expression_list\" || children.length != 1) {\n    return unsupportedSyntax(\"go\", subject, nodeLocation(node, filename, source))\n  }\n  return children[0]\n}\n\n/**\n * Converts one expression.\n * @param {import(\"tree-sitter\").SyntaxNode} node Expression node.\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.type == \"parenthesized_expression\") {\n    const children = semanticChildren(node)\n\n    if (children.length != 1) return unsupportedSyntax(\"go\", node.type, location)\n    return convertExpression(children[0], filename, source)\n  }\n  if (node.type == \"identifier\") {\n    const name = identifier(node, \"reference\", filename, source)\n\n    return withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location, name}, {name: location})\n  }\n  if (node.type == \"int_literal\") {\n    if (!/^(?:0|[1-9][0-9]*)$/u.test(node.text)) return unsupportedSyntax(\"go\", \"noncanonical integer literal\", location)\n    const value = Number(BigInt(node.text))\n\n    if (!Number.isSafeInteger(value)) return unsupportedSyntax(\"go\", \"non-safe integer literal\", location)\n    return withParserRanges({kind: /** @type {const} */ (\"IntegerLiteral\"), location, value}, {literal: location})\n  }\n  if (node.type == \"true\" || node.type == \"false\") {\n    return withParserRanges({kind: /** @type {const} */ (\"BooleanLiteral\"), location, value: node.type == \"true\"}, {literal: location})\n  }\n  if (node.type == \"interpreted_string_literal\") {\n    return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: decodeString(node, filename, source)}, {\n      literal: location\n    })\n  }\n  if (node.type == \"unary_expression\") {\n    const operand = requiredField(node, \"operand\", filename, source)\n    const operator = operatorToken(node, new Set([\"!\", \"-\"]), filename, source)\n\n    if (semanticChildren(node).length != 1) return unsupportedSyntax(\"go\", \"unary expression shape\", location)\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand: convertExpression(operand, filename, source)\n    }, {operator: nodeLocation(operator, filename, source)}), operator.type == \"!\" ? \"Not\" : \"Negate\")))\n  }\n  if (node.type == \"binary_expression\") {\n    const left = requiredField(node, \"left\", filename, source)\n    const right = requiredField(node, \"right\", filename, source)\n    const operator = operatorToken(node, new Set(binaryOperations.keys()), filename, source)\n    const adapted = binaryOperations.get(operator.type)\n\n    if (!adapted || semanticChildren(node).length != 2) return unsupportedSyntax(\"go\", \"binary expression shape\", location)\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\",\n      left: convertExpression(left, filename, source),\n      location,\n      right: convertExpression(right, filename, source)\n    }, {operator: nodeLocation(operator, filename, source)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (adapted))))\n  }\n  if (node.type == \"call_expression\") {\n    const calleeNode = requiredField(node, \"function\", filename, source)\n    const argumentsNode = requiredField(node, \"arguments\", filename, source)\n\n    if (calleeNode.type != \"identifier\" || argumentsNode.type != \"argument_list\" || semanticChildren(node).length != 2) {\n      return unsupportedSyntax(\"go\", \"qualified or dynamic call\", location)\n    }\n    const callee = identifier(calleeNode, \"callee\", filename, source)\n    const arguments_ = semanticChildren(argumentsNode).map((argument) => convertExpression(argument, filename, source))\n\n    return withParserRanges({arguments: arguments_, callee, kind: /** @type {const} */ (\"CallExpression\"), location}, {\n      callee: nodeLocation(calleeNode, filename, source)\n    })\n  }\n  return unsupportedSyntax(\"go\", node.type, location)\n}\n\n/**\n * Decodes an interpreted Go string to valid Unicode scalar text.\n * @param {import(\"tree-sitter\").SyntaxNode} node Literal node.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {string} Decoded value.\n */\nfunction decodeString(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const text = node.text\n\n  if (!text.startsWith('\"') || !text.endsWith('\"') || /[\\r\\n]/u.test(text)) {\n    return unsupportedSyntax(\"go\", \"noncanonical interpreted string literal\", location)\n  }\n  /** @type {number[]} */\n  const bytes = []\n  /**\n   * Appends one UTF-8 text segment.\n   * @param {string} value Text segment.\n   * @returns {number} New byte length.\n   */\n  const appendText = (value) => bytes.push(...new TextEncoder().encode(value))\n  const simple = new Map([\n    [\"a\", 7], [\"b\", 8], [\"f\", 12], [\"n\", 10], [\"r\", 13], [\"t\", 9], [\"v\", 11], [\"\\\\\", 92], ['\"', 34]\n  ])\n\n  for (let index = 1; index < text.length - 1; index += 1) {\n    const character = text[index]\n\n    if (character != \"\\\\\") {\n      const codePoint = text.codePointAt(index)\n\n      if (codePoint === undefined) return unsupportedSyntax(\"go\", \"invalid string literal\", location)\n      appendText(String.fromCodePoint(codePoint))\n      if (codePoint > 0xFFFF) index += 1\n      continue\n    }\n    const escape = text[++index]\n\n    if (escape === undefined) return unsupportedSyntax(\"go\", \"invalid string escape\", location)\n    if (simple.has(escape)) {\n      bytes.push(/** @type {number} */ (simple.get(escape)))\n      continue\n    }\n    if (escape == \"x\") {\n      const digits = text.slice(index + 1, index + 3)\n\n      if (!/^[0-9A-Fa-f]{2}$/u.test(digits)) return unsupportedSyntax(\"go\", \"invalid byte escape\", location)\n      bytes.push(Number.parseInt(digits, 16))\n      index += 2\n      continue\n    }\n    if (/[0-7]/u.test(escape)) {\n      const digits = text.slice(index, index + 3)\n\n      if (!/^[0-7]{3}$/u.test(digits)) return unsupportedSyntax(\"go\", \"invalid octal escape\", location)\n      const value = Number.parseInt(digits, 8)\n\n      if (value > 255) return unsupportedSyntax(\"go\", \"octal escape outside byte range\", location)\n      bytes.push(value)\n      index += 2\n      continue\n    }\n    const width = escape == \"u\" ? 4 : escape == \"U\" ? 8 : 0\n    const digits = text.slice(index + 1, index + 1 + width)\n\n    if (!width || digits.length != width || !/^[0-9A-Fa-f]+$/u.test(digits)) {\n      return unsupportedSyntax(\"go\", \"unsupported string escape\", location)\n    }\n    const value = Number.parseInt(digits, 16)\n\n    if (value > 0x10FFFF || value >= 0xD800 && value <= 0xDFFF) {\n      return unsupportedSyntax(\"go\", \"invalid Unicode string escape\", location)\n    }\n    appendText(String.fromCodePoint(value))\n    index += width\n  }\n  let decoded\n\n  try {\n    decoded = new TextDecoder(\"utf-8\", {fatal: true}).decode(Uint8Array.from(bytes))\n  } catch {\n    return unsupportedSyntax(\"go\", \"string byte escapes do not form valid UTF-8\", location)\n  }\n  if (!hasOnlyUnicodeScalars(decoded)) return unsupportedSyntax(\"go\", \"invalid Unicode string literal\", location)\n  return decoded\n}\n\n/**\n * Collects plain assignment targets in one root function.\n * @param {import(\"tree-sitter\").SyntaxNode} body Root body.\n * @returns {Set<string>} Assigned names.\n */\nfunction collectAssignmentTargets(body) {\n  const names = new Set()\n\n  for (const assignment of body.descendantsOfType(\"assignment_statement\")) {\n    const left = assignment.childForFieldName(\"left\")\n    const children = left ? semanticChildren(left) : []\n\n    if (left?.type == \"expression_list\" && children.length == 1 && children[0].type == \"identifier\") {\n      names.add(children[0].text)\n    }\n  }\n  return names\n}\n\n/**\n * Claims an exact adjacent immutable marker.\n * @param {import(\"tree-sitter\").SyntaxNode} node Local declaration.\n * @param {GoContext} context Comment context.\n * @returns {boolean} Whether marked immutable.\n */\nfunction takeImmutableMarker(node, context) {\n  const marker = context.comments.find((comment) => comment.text == immutableMarker &&\n    comment.endPosition.row + 1 == node.startPosition.row && comment.startPosition.column == node.startPosition.column)\n\n  if (!marker) return false\n  context.usedMarkers.add(marker)\n  return true\n}\n\n/**\n * Converts one exact initialized local.\n * @param {import(\"tree-sitter\").SyntaxNode} node Declaration node.\n * @param {GoContext} context Function context.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"../semantic/types.js\").LocalDeclaration} Semantic local.\n */\nfunction convertLocal(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const children = semanticChildren(node)\n\n  if (children.length != 1 || children[0].type != \"var_spec\") return unsupportedSyntax(\"go\", \"local declaration shape\", location)\n  const spec = children[0]\n  const nameNode = requiredField(spec, \"name\", filename, source)\n  const typeNode = spec.childForFieldName(\"type\")\n  const valueNode = requiredField(spec, \"value\", filename, source)\n\n  if (semanticChildren(spec).length != (typeNode ? 3 : 2)) return unsupportedSyntax(\"go\", \"local declaration shape\", location)\n  const expressionNode = soleExpression(valueNode, \"local initializer count\", filename, source)\n  const name = identifier(nameNode, \"local\", filename, source)\n  const markedImmutable = takeImmutableMarker(node, context)\n  const operator = operatorToken(spec, new Set([\"=\"]), filename, source)\n\n  return withParserRanges({\n    initializer: convertExpression(expressionNode, filename, source),\n    kind: /** @type {const} */ (\"LocalDeclaration\"),\n    location,\n    mutable: !markedImmutable && context.assignmentTargets.has(name),\n    name,\n    type: convertType(typeNode, \"Local '\" + name + \"'\", location, filename, source)\n  }, {name: nodeLocation(nameNode, filename, source), operator: nodeLocation(operator, filename, source)})\n}\n\n/**\n * Converts one plain assignment.\n * @param {import(\"tree-sitter\").SyntaxNode} node Assignment node.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"../semantic/types.js\").AssignmentStatement} Semantic assignment.\n */\nfunction convertAssignment(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const leftList = requiredField(node, \"left\", filename, source)\n  const rightList = requiredField(node, \"right\", filename, source)\n  const operator = operatorToken(node, new Set([\"=\"]), filename, source)\n  const left = soleExpression(leftList, \"assignment target count\", filename, source)\n  const right = soleExpression(rightList, \"assignment value count\", filename, source)\n\n  if (left.type != \"identifier\" || semanticChildren(node).length != 2) {\n    return unsupportedSyntax(\"go\", \"assignment shape\", location)\n  }\n  const name = identifier(left, \"assignment target\", filename, source)\n  const nameLocation = nodeLocation(left, filename, source)\n\n  return withParserRanges({\n    expression: convertExpression(right, filename, source),\n    kind: /** @type {const} */ (\"AssignmentStatement\"),\n    location,\n    target: withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: nameLocation, name}, {name: nameLocation})\n  }, {operator: nodeLocation(operator, filename, source)})\n}\n\n/**\n * Recognizes exact fmt.Println.\n * @param {import(\"tree-sitter\").SyntaxNode} node Candidate selector.\n * @returns {boolean} Exact print receiver.\n */\nfunction isPrintReceiver(node) {\n  return node.type == \"selector_expression\" && semanticChildren(node).length == 2 &&\n    node.childForFieldName(\"operand\")?.type == \"identifier\" && node.childForFieldName(\"operand\")?.text == \"fmt\" &&\n    node.childForFieldName(\"field\")?.type == \"field_identifier\" && node.childForFieldName(\"field\")?.text == \"Println\"\n}\n\n/**\n * Converts one print expression statement.\n * @param {import(\"tree-sitter\").SyntaxNode} node 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(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const children = semanticChildren(node)\n\n  if (children.length != 1 || children[0].type != \"call_expression\") {\n    return unsupportedSyntax(\"go\", \"expression statement other than print\", location)\n  }\n  const call = children[0]\n  const callee = requiredField(call, \"function\", filename, source)\n  const argumentsNode = requiredField(call, \"arguments\", filename, source)\n  const arguments_ = semanticChildren(argumentsNode)\n\n  if (!isPrintReceiver(callee) || semanticChildren(call).length != 2 || argumentsNode.type != \"argument_list\" ||\n    arguments_.length != 1) {\n    return unsupportedSyntax(\"go\", \"print call shape\", nodeLocation(call, filename, source))\n  }\n  return {expression: convertExpression(arguments_[0], filename, source), kind: /** @type {const} */ (\"PrintStatement\"), location}\n}\n\n/**\n * Converts one conditional.\n * @param {import(\"tree-sitter\").SyntaxNode} node If node.\n * @param {GoContext} context Function context.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"../semantic/types.js\").IfStatement} Semantic conditional.\n */\nfunction convertIf(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const condition = requiredField(node, \"condition\", filename, source)\n  const consequence = requiredField(node, \"consequence\", filename, source)\n  const alternative = node.childForFieldName(\"alternative\")\n  const expectedChildren = alternative ? 3 : 2\n\n  if (semanticChildren(node).length != expectedChildren) return unsupportedSyntax(\"go\", \"if initializer or shape\", location)\n  return {\n    ...(alternative ? {alternate: alternative.type == \"if_statement\"\n      ? {kind: /** @type {const} */ (\"Block\"), location: nodeLocation(alternative, filename, source),\n          statements: [convertIf(alternative, context, filename, source)]}\n      : convertBlock(alternative, context, filename, source)} : {}),\n    condition: convertExpression(condition, filename, source),\n    consequent: convertBlock(consequence, context, filename, source),\n    kind: /** @type {const} */ (\"IfStatement\"),\n    location\n  }\n}\n\n/**\n * Converts one supported statement.\n * @param {import(\"tree-sitter\").SyntaxNode} node Statement node.\n * @param {GoContext} context Function context.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"../semantic/types.js\").Statement} Semantic statement.\n */\nfunction convertStatement(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type == \"var_declaration\") return convertLocal(node, context, filename, source)\n  if (node.type == \"assignment_statement\") return convertAssignment(node, filename, source)\n  if (node.type == \"if_statement\") return convertIf(node, context, filename, source)\n  if (node.type == \"expression_statement\") return convertPrint(node, filename, source)\n  if (node.type == \"return_statement\") {\n    const children = semanticChildren(node)\n\n    if (children.length != 1) return unsupportedSyntax(\"go\", \"return without one expression\", location)\n    return {\n      expression: convertExpression(soleExpression(children[0], \"return expression count\", filename, source), filename, source),\n      kind: /** @type {const} */ (\"ReturnStatement\"),\n      location\n    }\n  }\n  return unsupportedSyntax(\"go\", node.type, location)\n}\n\n/**\n * Converts one lexical block.\n * @param {import(\"tree-sitter\").SyntaxNode} node Block node.\n * @param {GoContext} context Function context.\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, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const children = semanticChildren(node)\n\n  if (node.type != \"block\" || children.length > 1 || children[0]?.type != \"statement_list\") {\n    if (!(node.type == \"block\" && children.length == 0)) return unsupportedSyntax(\"go\", \"block shape\", location)\n  }\n  const statements = children.length == 0 ? [] : semanticChildren(children[0])\n\n  return {kind: /** @type {const} */ (\"Block\"), location,\n    statements: statements.map((statement) => convertStatement(statement, context, filename, source))}\n}\n\n/**\n * Converts one parameter.\n * @param {import(\"tree-sitter\").SyntaxNode} node Parameter node.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"../semantic/types.js\").Parameter} Semantic parameter.\n */\nfunction convertParameter(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const nameNode = requiredField(node, \"name\", filename, source)\n  const typeNode = node.childForFieldName(\"type\")\n\n  if (node.type != \"parameter_declaration\" || semanticChildren(node).length != 2) {\n    return unsupportedSyntax(\"go\", \"parameter shape\", location)\n  }\n  const name = identifier(nameNode, \"parameter\", filename, source)\n\n  return withParserRanges({\n    kind: /** @type {const} */ (\"Parameter\"),\n    location,\n    name,\n    type: convertType(typeNode, \"Parameter '\" + name + \"'\", location, filename, source)\n  }, {name: nodeLocation(nameNode, filename, source)})\n}\n\n/**\n * Converts one semantic function.\n * @param {import(\"tree-sitter\").SyntaxNode} node Function node.\n * @param {GoContext} baseContext File context.\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, baseContext, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const nameNode = requiredField(node, \"name\", filename, source)\n  const parametersNode = requiredField(node, \"parameters\", filename, source)\n  const resultNode = node.childForFieldName(\"result\")\n  const bodyNode = requiredField(node, \"body\", filename, source)\n\n  if (node.type != \"function_declaration\" || semanticChildren(node).length != (resultNode ? 4 : 3) ||\n    node.childForFieldName(\"receiver\") || node.childForFieldName(\"type_parameters\")) {\n    return unsupportedSyntax(\"go\", \"function declaration shape\", location)\n  }\n  const name = identifier(nameNode, \"function\", filename, source)\n  const parameterNodes = semanticChildren(parametersNode)\n\n  if (parameterNodes.length != 2 || parameterNodes.some((parameter) => parameter.type != \"parameter_declaration\")) {\n    return unsupportedSyntax(\"go\", \"function parameter count or shape\", nodeLocation(parametersNode, filename, source))\n  }\n  const context = {...baseContext, assignmentTargets: collectAssignmentTargets(bodyNode)}\n\n  return withParserRanges({\n    body: convertBlock(bodyNode, context, filename, source),\n    kind: /** @type {const} */ (\"FunctionDeclaration\"),\n    location,\n    name,\n    parameters: parameterNodes.map((parameter) => convertParameter(parameter, filename, source)),\n    returnType: convertType(resultNode, \"Function '\" + name + \"' return\", location, filename, source)\n  }, {name: nodeLocation(nameNode, filename, source)})\n}\n\n/**\n * Converts the exact final func main() entry.\n * @param {import(\"tree-sitter\").SyntaxNode} node Main node.\n * @param {GoContext} baseContext File context.\n * @param {string} filename Source filename.\n * @param {string} source Complete source.\n * @returns {import(\"../semantic/types.js\").EntryPoint} Semantic entry.\n */\nfunction convertMain(node, baseContext, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const name = requiredField(node, \"name\", filename, source)\n  const parameters = requiredField(node, \"parameters\", filename, source)\n  const body = requiredField(node, \"body\", filename, source)\n\n  if (semanticChildren(node).length != 3 || name.text != \"main\" || semanticChildren(parameters).length != 0 ||\n    node.childForFieldName(\"result\") || node.childForFieldName(\"receiver\") || node.childForFieldName(\"type_parameters\")) {\n    return unsupportedSyntax(\"go\", \"main scaffolding\", location)\n  }\n  const context = {...baseContext, assignmentTargets: collectAssignmentTargets(body)}\n\n  return {body: convertBlock(body, context, filename, source), kind: /** @type {const} */ (\"EntryPoint\"), location}\n}\n\n/**\n * Reports whether any print exists.\n * @param {import(\"../semantic/types.js\").SemanticModule} module Module.\n * @returns {boolean} Print presence.\n */\nfunction hasPrint(module) {\n  /**\n   * Reports whether one nested block prints.\n   * @type {(block: import(\"../semantic/types.js\").Block) => boolean}\n   */\n  const blockHasPrint = (block) => block.statements.some((statement) => statement.kind == \"PrintStatement\" ||\n    statement.kind == \"IfStatement\" && (blockHasPrint(statement.consequent) || Boolean(statement.alternate && blockHasPrint(statement.alternate))))\n\n  return module.functions.some(({body}) => blockHasPrint(body)) || blockHasPrint(module.entryPoint.body)\n}\n\n/**\n * Parses the strict Task 024 Go profile.\n * @param {{filename: string, source: string}} input Parser input.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parseGo({filename, source}) {\n  if (!hasOnlyUnicodeScalars(source)) {\n    const offset = firstLoneSurrogateOffset(source)\n\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\",\n      language: \"go\",\n      location: locationFromOffsets(filename, source, offset, offset + 1),\n      message: \"Go 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    return parseFailure(\"go\", error)\n  }\n  const root = tree.rootNode\n\n  validateParserTree(root, filename, source)\n  if (root.type != \"source_file\") throw new Error(\"Tree-sitter returned Go root '\" + root.type + \"'.\")\n  const location = moduleLocation(filename, source)\n  const comments = root.descendantsOfType(\"comment\")\n\n  for (const comment of comments) {\n    if (/^\\/\\/go:/u.test(comment.text) || /^\\/\\/ \\+build(?:\\s|$)/u.test(comment.text) ||\n      /^\\/\\/line(?:\\s|$)/u.test(comment.text) || /^\\/\\*line(?:\\s|$)/u.test(comment.text)) {\n      return unsupportedSyntax(\"go\", \"source directive\", nodeLocation(comment, filename, source))\n    }\n    if (comment.text.includes(\"@semantifold\") && comment.text != immutableMarker) {\n      return unsupportedSyntax(\"go\", \"invalid Semantifold metadata comment\", nodeLocation(comment, filename, source))\n    }\n  }\n  const children = semanticChildren(root)\n\n  if (children.length < 3 || children[0].type != \"package_clause\") {\n    return unsupportedSyntax(\"go\", \"compilation-unit scaffolding\", location)\n  }\n  const packageChildren = semanticChildren(children[0])\n\n  if (packageChildren.length != 1 || packageChildren[0].type != \"package_identifier\" || packageChildren[0].text != \"main\") {\n    return unsupportedSyntax(\"go\", \"package main scaffolding\", nodeLocation(children[0], filename, source))\n  }\n  let memberStart = 1\n  let hasFmtImport = false\n\n  if (children[1]?.type == \"import_declaration\") {\n    const declaration = children[1]\n    const imports = semanticChildren(declaration)\n\n    if (imports.length != 1 || imports[0].type != \"import_spec\" || semanticChildren(imports[0]).length != 1 ||\n      imports[0].childForFieldName(\"path\")?.type != \"interpreted_string_literal\" ||\n      imports[0].childForFieldName(\"path\")?.text != '\"fmt\"') {\n      return unsupportedSyntax(\"go\", \"fmt import scaffolding\", nodeLocation(declaration, filename, source))\n    }\n    hasFmtImport = true\n    memberStart = 2\n  }\n  const members = children.slice(memberStart)\n\n  if (members.length < 2 || members.some((member) => member.type != \"function_declaration\")) {\n    return unsupportedSyntax(\"go\", \"top-level declarations\", location)\n  }\n  const mainNodes = members.filter((member) => member.childForFieldName(\"name\")?.text == \"main\")\n\n  if (mainNodes.length != 1 || members.at(-1)?.id != mainNodes[0].id) {\n    return unsupportedSyntax(\"go\", \"main ordering\", location)\n  }\n  const baseContext = {assignmentTargets: new Set(), comments, usedMarkers: new Set()}\n  const module = {\n    entryPoint: convertMain(mainNodes[0], baseContext, filename, source),\n    functions: members.slice(0, -1).map((member) => convertFunction(member, baseContext, filename, source)),\n    kind: /** @type {const} */ (\"Module\"),\n    location\n  }\n  const invalidMarker = comments.find((comment) => comment.text == immutableMarker && !baseContext.usedMarkers.has(comment))\n\n  if (invalidMarker) return unsupportedSyntax(\"go\", \"unattached immutable marker\", nodeLocation(invalidMarker, filename, source))\n  if (hasFmtImport != hasPrint(module)) return unsupportedSyntax(\"go\", \"fmt import and print usage mismatch\", location)\n  validateParsedModule(module, \"go\")\n  return module\n}\n"]}