semantifold 0.1.1 → 0.2.0

package/build/src/frontends/python.js

@@ -0,0 +1,615 @@
+// @ts-check
+import Parser from "tree-sitter";
+import PythonLanguage from "tree-sitter-python";
+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 { requireSourceScalarType } from "./scalars.js";
+const parser = new Parser();
+parser.setLanguage(/** @type {import("tree-sitter").Language} */ ( /** @type {unknown} */(PythonLanguage)));
+const immutableMarker = "# @semantifold-immutable";
+const pythonReservedIdentifiers = new Set([
+    "False", "None", "True", "and", "as", "assert", "async", "await", "break", "case", "class", "continue",
+    "def", "del", "elif", "else", "except", "exec", "finally", "for", "from", "global", "if", "import", "in",
+    "is", "lambda", "match", "nonlocal", "not", "or", "pass", "print", "raise", "return", "try", "type",
+    "while", "with", "yield", "_", "__debug__", "int", "bool", "str"
+]);
+const binaryOperations = new Map([
+    ["+", "Add"],
+    ["-", "Subtract"],
+    ["*", "Multiply"]
+]);
+const comparisonOperations = new Map([
+    ["==", "Equal"],
+    ["!=", "NotEqual"],
+    ["<", "LessThan"],
+    ["<=", "LessThanOrEqual"],
+    [">", "GreaterThan"],
+    [">=", "GreaterThanOrEqual"]
+]);
+/** @typedef {{comments: import("tree-sitter").SyntaxNode[], usedImmutableMarkers: Set<import("tree-sitter").SyntaxNode>}} PythonContext */
+/**
+ * Routes the binding's UTF-16 index through the shared UTF-8 byte converter.
+ * node-tree-sitter parses JavaScript strings as UTF-16LE and exposes code-unit
+ * indexes even though the grammar's native coordinate contract is byte-based.
+ * @param {string} source - Complete source.
+ * @param {number} index - Binding 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}`);
+    }
+    const byteOffset = new TextEncoder().encode(source.slice(0, index)).length;
+    return utf8ByteOffsetToUtf16Offset(source, byteOffset);
+}
+/**
+ * Finds the first 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 a Tree-sitter byte range into Semantifold's UTF-16 coordinates.
+ * @param {import("tree-sitter").SyntaxNode} node - Parser 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 parser field.
+ * @param {import("tree-sitter").SyntaxNode} node - Field owner.
+ * @param {string} field - Grammar field name.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("tree-sitter").SyntaxNode} Field node.
+ */
+function requiredField(node, field, filename, source) {
+    const child = node.childForFieldName(field);
+    if (!child)
+        return unsupportedSyntax("python", `${node.type} without ${field}`, nodeLocation(node, filename, source));
+    return child;
+}
+/**
+ * Validates every named and anonymous parser child and rejects recovery.
+ * @param {import("tree-sitter").SyntaxNode} node - Current parser node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {void}
+ */
+function validateParserTree(node, filename, source) {
+    if (node.isError || node.isMissing) {
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR",
+            language: "python",
+            location: nodeLocation(node, filename, source),
+            message: `Tree-sitter exposed ${node.isMissing ? "a missing" : "an error"} recovery node '${node.type}'.`
+        });
+    }
+    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);
+    }
+}
+/**
+ * Rejects Python identifiers that cannot safely participate in the exact profile.
+ * @param {import("tree-sitter").SyntaxNode} node - Identifier node.
+ * @param {string} role - Diagnostic role.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {string} Accepted name.
+ */
+function identifier(node, role, filename, source) {
+    const name = node.text;
+    if (node.type != "identifier" || pythonReservedIdentifiers.has(name) || name.normalize("NFKC") != name) {
+        return unsupportedSyntax("python", `${role} identifier '${name}'`, nodeLocation(node, filename, source));
+    }
+    return name;
+}
+/**
+ * Converts one exact int/bool/str annotation.
+ * @param {import("tree-sitter").SyntaxNode | null} node - Type node, if present.
+ * @param {string} subject - Typed subject.
+ * @param {import("../semantic/types.js").SourceLocation} ownerLocation - Owning declaration.
+ * @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("python", subject, ownerLocation);
+    const typeLocation = nodeLocation(node, filename, source);
+    const children = node.namedChildren.filter((child) => child.type != "comment");
+    if (node.type != "type" || children.length != 1 || children[0].type != "identifier" ||
+        !["int", "bool", "str"].includes(children[0].text) || node.text != children[0].text) {
+        return unsupportedSyntax("python", "unsupported scalar annotation", typeLocation);
+    }
+    return requireSourceScalarType("python", children[0].text, subject, ownerLocation, typeLocation);
+}
+/**
+ * Finds exactly one anonymous operator token directly owned by a parser node.
+ * @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 tokens = node.children.filter((child) => !child.isNamed && spellings.has(child.type));
+    if (tokens.length != 1)
+        return unsupportedSyntax("python", `${node.type} operator`, nodeLocation(node, filename, source));
+    return tokens[0];
+}
+/**
+ * Converts one supported Python 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 expressions = node.namedChildren.filter((child) => child.type != "comment");
+        if (expressions.length != 1)
+            return unsupportedSyntax("python", node.type, location);
+        return convertExpression(expressions[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 == "integer") {
+        let value;
+        try {
+            value = Number(BigInt(node.text.replaceAll("_", "")));
+        }
+        catch {
+            return unsupportedSyntax("python", "integer literal", location);
+        }
+        if (!Number.isSafeInteger(value))
+            return unsupportedSyntax("python", "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 == "string") {
+        return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: decodeString(node, filename, source) }, {
+            literal: location
+        });
+    }
+    if (node.type == "concatenated_string")
+        return unsupportedSyntax("python", "implicit string concatenation", location);
+    if (node.type == "unary_operator") {
+        const operandNode = requiredField(node, "argument", filename, source);
+        const operator = operatorToken(node, new Set(["-"]), filename, source);
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand: convertExpression(operandNode, filename, source)
+        }, { operator: nodeLocation(operator, filename, source) }), "Negate");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.type == "not_operator") {
+        const operandNode = requiredField(node, "argument", filename, source);
+        const operator = operatorToken(node, new Set(["not"]), filename, source);
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand: convertExpression(operandNode, filename, source)
+        }, { operator: nodeLocation(operator, filename, source) }), "Not");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.type == "binary_operator" || node.type == "comparison_operator" || node.type == "boolean_operator") {
+        const expressionChildren = node.namedChildren.filter((child) => child.type != "comment");
+        const leftNode = node.childForFieldName("left") ?? expressionChildren[0];
+        const rightNode = node.childForFieldName("right") ?? expressionChildren[1];
+        if (!leftNode || !rightNode)
+            return unsupportedSyntax("python", node.type, location);
+        const operations = node.type == "binary_operator" ? binaryOperations : node.type == "comparison_operator"
+            ? comparisonOperations : new Map([["and", "And"], ["or", "Or"]]);
+        const operator = operatorToken(node, new Set(operations.keys()), filename, source);
+        const adapted = operations.get(operator.type);
+        if (!adapted || expressionChildren.length != 2) {
+            return unsupportedSyntax("python", node.type, location);
+        }
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression",
+            left: convertExpression(leftNode, filename, source),
+            location,
+            right: convertExpression(rightNode, filename, source)
+        }, { operator: nodeLocation(operator, filename, source) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (adapted));
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.type == "call") {
+        const calleeNode = requiredField(node, "function", filename, source);
+        const argumentsNode = requiredField(node, "arguments", filename, source);
+        if (calleeNode.type != "identifier" || argumentsNode.type != "argument_list") {
+            return unsupportedSyntax("python", "dynamic call", location);
+        }
+        const callee = identifier(calleeNode, "callee", filename, source);
+        const arguments_ = argumentsNode.namedChildren.filter((child) => child.type != "comment")
+            .map((argument) => convertExpression(argument, filename, source));
+        return withParserRanges({ arguments: arguments_, callee, kind: /** @type {const} */ ("CallExpression"), location }, {
+            callee: nodeLocation(calleeNode, filename, source)
+        });
+    }
+    return unsupportedSyntax("python", node.type, location);
+}
+/**
+ * Decodes one non-prefixed, non-triple Python string without evaluating source.
+ * @param {import("tree-sitter").SyntaxNode} node - String node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {string} Unicode scalar string.
+ */
+function decodeString(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const text = node.text;
+    const quote = text[0];
+    if ((quote != "\"" && quote != "'") || text.at(-1) != quote || text.startsWith(`${quote}${quote}${quote}`)) {
+        return unsupportedSyntax("python", "prefixed or triple-quoted string", location);
+    }
+    let decoded = "";
+    for (let index = 1; index < text.length - 1; index += 1) {
+        const character = text[index];
+        if (character != "\\") {
+            decoded += character;
+            continue;
+        }
+        const escape = text[++index];
+        if (escape === undefined)
+            return unsupportedSyntax("python", "invalid string escape", location);
+        const simple = new Map([
+            ["\\", "\\"], ["'", "'"], ["\"", "\""], ["a", "\u0007"], ["b", "\b"], ["f", "\f"], ["n", "\n"],
+            ["r", "\r"], ["t", "\t"], ["v", "\v"]
+        ]);
+        if (simple.has(escape)) {
+            decoded += simple.get(escape);
+            continue;
+        }
+        if (/[0-7]/u.test(escape)) {
+            let digits = escape;
+            while (digits.length < 3 && /[0-7]/u.test(text[index + 1] ?? ""))
+                digits += text[++index];
+            decoded += String.fromCodePoint(Number.parseInt(digits, 8));
+            continue;
+        }
+        const widths = new Map([["x", 2], ["u", 4], ["U", 8]]);
+        const width = widths.get(escape);
+        if (!width)
+            return unsupportedSyntax("python", `unsupported string escape \\${escape}`, location);
+        const digits = text.slice(index + 1, index + 1 + width);
+        if (digits.length != width || !/^[0-9A-Fa-f]+$/u.test(digits))
+            return unsupportedSyntax("python", "invalid string escape", location);
+        index += width;
+        const codePoint = Number.parseInt(digits, 16);
+        if (codePoint > 0x10FFFF || codePoint >= 0xD800 && codePoint <= 0xDFFF) {
+            return unsupportedSyntax("python", "invalid Unicode string escape", location);
+        }
+        decoded += String.fromCodePoint(codePoint);
+    }
+    if (!hasOnlyUnicodeScalars(decoded))
+        return unsupportedSyntax("python", "invalid Unicode string literal", location);
+    return decoded;
+}
+/**
+ * Converts one annotated assignment or plain assignment.
+ * @param {import("tree-sitter").SyntaxNode} node - Assignment node.
+ * @param {PythonContext} context - Comment association state.
+ * @param {Set<string>} visible - Visible bindings in this lexical scope.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").LocalStatement} Semantic local statement.
+ */
+function convertAssignment(node, context, visible, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const left = requiredField(node, "left", filename, source);
+    const right = requiredField(node, "right", filename, source);
+    const typeNode = node.childForFieldName("type");
+    if (left.type != "identifier")
+        return unsupportedSyntax("python", "non-identifier assignment target", nodeLocation(left, filename, source));
+    const name = identifier(left, typeNode ? "local" : "assignment target", filename, source);
+    const nameLocation = nodeLocation(left, filename, source);
+    const operator = operatorToken(node, new Set(["="]), filename, source);
+    if (!typeNode) {
+        if (!visible.has(name))
+            return missingType("python", `Local '${name}'`, location);
+        const target = withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: nameLocation, name }, { name: nameLocation });
+        return withParserRanges({
+            expression: convertExpression(right, filename, source),
+            kind: /** @type {const} */ ("AssignmentStatement"),
+            location,
+            target
+        }, { operator: nodeLocation(operator, filename, source) });
+    }
+    const declaration = withParserRanges({
+        initializer: convertExpression(right, filename, source),
+        kind: /** @type {const} */ ("LocalDeclaration"),
+        location,
+        mutable: !takeImmutableMarker(node, context),
+        name,
+        type: convertType(typeNode, `Local '${name}'`, location, filename, source)
+    }, { name: nameLocation, operator: nodeLocation(operator, filename, source) });
+    visible.add(name);
+    return declaration;
+}
+/**
+ * Associates the exact immediately preceding immutable marker with a local.
+ * @param {import("tree-sitter").SyntaxNode} node - Local assignment.
+ * @param {PythonContext} context - Comment state.
+ * @returns {boolean} Whether the local is 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.usedImmutableMarkers.add(marker);
+    return true;
+}
+/**
+ * Converts one statement.
+ * @param {import("tree-sitter").SyntaxNode} node - Statement node.
+ * @param {PythonContext} context - Comment state.
+ * @param {Set<string>} visible - Visible bindings in this lexical scope.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Statement} Semantic statement.
+ */
+function convertStatement(node, context, visible, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type == "return_statement") {
+        const expressions = node.namedChildren.filter((child) => child.type != "comment");
+        if (expressions.length != 1)
+            return unsupportedSyntax("python", "return without one expression", location);
+        return { expression: convertExpression(expressions[0], filename, source), kind: "ReturnStatement", location };
+    }
+    if (node.type == "if_statement")
+        return convertIf(node, context, visible, filename, source);
+    if (node.type == "expression_statement") {
+        const expressions = node.namedChildren.filter((child) => child.type != "comment");
+        if (expressions.length != 1)
+            return unsupportedSyntax("python", node.type, location);
+        if (expressions[0].type == "assignment")
+            return convertAssignment(expressions[0], context, visible, filename, source);
+        return convertPrint(expressions[0], filename, source, location);
+    }
+    return unsupportedSyntax("python", node.type, location);
+}
+/**
+ * Converts the exact print(expression) statement.
+ * @param {import("tree-sitter").SyntaxNode} node - Expression statement value.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @param {import("../semantic/types.js").SourceLocation} location - Whole statement location.
+ * @returns {import("../semantic/types.js").PrintStatement} Print statement.
+ */
+function convertPrint(node, filename, source, location) {
+    if (node.type != "call")
+        return unsupportedSyntax("python", "entry expression other than print", nodeLocation(node, filename, source));
+    const callee = requiredField(node, "function", filename, source);
+    const argumentsNode = requiredField(node, "arguments", filename, source);
+    const arguments_ = argumentsNode.namedChildren.filter((child) => child.type != "comment");
+    if (callee.type != "identifier" || callee.text != "print" || argumentsNode.type != "argument_list" || arguments_.length != 1) {
+        return unsupportedSyntax("python", "print call shape", nodeLocation(node, filename, source));
+    }
+    return { expression: convertExpression(arguments_[0], filename, source), kind: "PrintStatement", location };
+}
+/**
+ * Converts one if/elif/else node into nested semantic blocks.
+ * @param {import("tree-sitter").SyntaxNode} node - If or elif node.
+ * @param {PythonContext} context - Comment state.
+ * @param {Set<string>} visible - Visible bindings in this lexical scope.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").IfStatement} Semantic branch.
+ */
+function convertIf(node, context, visible, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const conditionNode = requiredField(node, "condition", filename, source);
+    const consequenceNode = requiredField(node, "consequence", filename, source);
+    const alternativeNodes = node.namedChildren.filter((_child, index) => node.fieldNameForNamedChild(index) == "alternative");
+    const alternate = convertAlternatives(alternativeNodes, context, new Set(visible), filename, source);
+    return {
+        ...(alternate ? { alternate } : {}),
+        condition: convertExpression(conditionNode, filename, source),
+        consequent: convertBlock(consequenceNode, context, new Set(visible), filename, source),
+        kind: "IfStatement",
+        location
+    };
+}
+/**
+ * Converts an else block or nests one elif inside its semantic alternate block.
+ * @param {import("tree-sitter").SyntaxNode[]} nodes - Ordered elif/else nodes.
+ * @param {PythonContext} context - Comment state.
+ * @param {Set<string>} visible - Visible bindings in this lexical scope.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Block | undefined} Alternate block.
+ */
+function convertAlternatives(nodes, context, visible, filename, source) {
+    /** @type {import("../semantic/types.js").Block | undefined} */
+    let alternate;
+    for (let index = nodes.length - 1; index >= 0; index -= 1) {
+        const node = nodes[index];
+        if (node.type == "else_clause") {
+            if (alternate)
+                return unsupportedSyntax("python", "multiple else clauses", nodeLocation(node, filename, source));
+            alternate = convertBlock(requiredField(node, "body", filename, source), context, new Set(visible), filename, source);
+            continue;
+        }
+        if (node.type != "elif_clause")
+            return unsupportedSyntax("python", node.type, nodeLocation(node, filename, source));
+        const nested = convertIf(node, context, new Set(visible), filename, source);
+        if (alternate)
+            nested.alternate = alternate;
+        alternate = { kind: "Block", location: nodeLocation(node, filename, source), statements: [nested] };
+    }
+    return alternate;
+}
+/**
+ * Converts one indentation block and permits pass only as its sole executable node.
+ * @param {import("tree-sitter").SyntaxNode} node - Block node.
+ * @param {PythonContext} context - Comment state.
+ * @param {Set<string>} visible - Visible bindings in this lexical scope.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Block} Semantic block.
+ */
+function convertBlock(node, context, visible, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type != "block")
+        return unsupportedSyntax("python", node.type, location);
+    const statements = node.namedChildren.filter((child) => child.type != "comment");
+    if (statements.some((statement) => statement.type == "pass_statement")) {
+        if (statements.length != 1)
+            return unsupportedSyntax("python", "pass with executable siblings", location);
+        return { kind: "Block", location, statements: [] };
+    }
+    return { kind: "Block", location, statements: statements.map((statement) => convertStatement(statement, context, visible, filename, source)) };
+}
+/**
+ * Converts one exact synchronous top-level function.
+ * @param {import("tree-sitter").SyntaxNode} node - Function node.
+ * @param {PythonContext} context - Comment state.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+ */
+function convertFunction(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type != "function_definition" || node.children.some((child) => !child.isNamed && child.type == "async")) {
+        return unsupportedSyntax("python", node.type, location);
+    }
+    const typeParametersNode = node.childForFieldName("type_parameters");
+    if (typeParametersNode) {
+        return unsupportedSyntax("python", typeParametersNode.type, nodeLocation(typeParametersNode, filename, source));
+    }
+    const nameNode = requiredField(node, "name", filename, source);
+    const parametersNode = requiredField(node, "parameters", filename, source);
+    const returnNode = node.childForFieldName("return_type");
+    const bodyNode = requiredField(node, "body", filename, source);
+    const name = identifier(nameNode, "function", filename, source);
+    const parameterNodes = parametersNode.namedChildren.filter((child) => child.type != "comment");
+    if (parametersNode.children.some((child) => !child.isNamed && !["(", ")", ","].includes(child.type))) {
+        return unsupportedSyntax("python", "parameter separators", nodeLocation(parametersNode, filename, source));
+    }
+    const parameters = parameterNodes.map((parameterNode) => {
+        const parameterLocation = nodeLocation(parameterNode, filename, source);
+        if (parameterNode.type != "typed_parameter") {
+            if (parameterNode.type == "identifier")
+                return missingType("python", `Parameter '${parameterNode.text}'`, parameterLocation);
+            return unsupportedSyntax("python", parameterNode.type, parameterLocation);
+        }
+        const parameterNameNode = parameterNode.namedChildren.find((child) => child.type == "identifier");
+        const typeNode = parameterNode.childForFieldName("type");
+        if (!parameterNameNode)
+            return unsupportedSyntax("python", "parameter without identifier", parameterLocation);
+        const parameterName = identifier(parameterNameNode, "parameter", filename, source);
+        return withParserRanges({
+            kind: /** @type {const} */ ("Parameter"),
+            location: parameterLocation,
+            name: parameterName,
+            type: convertType(typeNode, `Parameter '${parameterName}'`, parameterLocation, filename, source)
+        }, { name: nodeLocation(parameterNameNode, filename, source) });
+    });
+    const visible = new Set(parameters.map((parameter) => parameter.name));
+    return withParserRanges({
+        body: convertBlock(bodyNode, context, visible, filename, source),
+        kind: "FunctionDeclaration",
+        location,
+        name,
+        parameters,
+        returnType: convertType(returnNode, `Function '${name}' return`, location, filename, source)
+    }, { name: nodeLocation(nameNode, filename, source) });
+}
+/**
+ * Parses the strict Task 016 Python profile.
+ * @param {{filename: string, source: string}} input - Parser input.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parsePython({ filename, source }) {
+    if (!hasOnlyUnicodeScalars(source)) {
+        const invalidOffset = firstLoneSurrogateOffset(source);
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR",
+            language: "python",
+            location: locationFromOffsets(filename, source, invalidOffset, invalidOffset + 1),
+            message: "Python source contains an invalid lone UTF-16 surrogate."
+        });
+    }
+    let tree;
+    try {
+        tree = parser.parse(source);
+    }
+    catch (error) {
+        return parseFailure("python", error);
+    }
+    const root = tree.rootNode;
+    validateParserTree(root, filename, source);
+    if (root.type != "module")
+        throw new Error(`Tree-sitter returned Python root '${root.type}'.`);
+    const comments = root.descendantsOfType("comment");
+    const context = { comments, usedImmutableMarkers: new Set() };
+    const functions = [];
+    const entryNodes = [];
+    let sawEntry = false;
+    for (const node of root.namedChildren) {
+        if (node.type == "comment")
+            continue;
+        if (node.type == "function_definition" && !sawEntry)
+            functions.push(convertFunction(node, context, filename, source));
+        else {
+            sawEntry = true;
+            entryNodes.push(node);
+        }
+    }
+    const location = moduleLocation(filename, source);
+    const entryLocation = entryNodes.length == 0 ? location : locationFromOffsets(filename, source, bindingIndexToUtf16Offset(source, entryNodes[0].startIndex), bindingIndexToUtf16Offset(source, entryNodes.at(-1)?.endIndex ?? root.endIndex));
+    const entryVisible = new Set();
+    const entryHasPass = entryNodes.some((node) => node.type == "pass_statement");
+    if (entryHasPass && entryNodes.length != 1) {
+        return unsupportedSyntax("python", "top-level pass with executable siblings", entryLocation);
+    }
+    const entryBlock = {
+        kind: /** @type {const} */ ("Block"),
+        location: entryLocation,
+        statements: entryHasPass ? [] : entryNodes.map((node) => convertStatement(node, context, entryVisible, filename, source))
+    };
+    const unusedMarker = comments.find((comment) => comment.text == immutableMarker && !context.usedImmutableMarkers.has(comment));
+    if (unusedMarker)
+        return unsupportedSyntax("python", "unattached immutable marker", nodeLocation(unusedMarker, filename, source));
+    if (functions.length == 0)
+        return unsupportedSyntax("python", "module without a function", location);
+    return {
+        entryPoint: { body: entryBlock, kind: "EntryPoint", location: entryLocation },
+        functions,
+        kind: "Module",
+        location
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"python.js","sourceRoot":"","sources":["../../../src/frontends/python.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Parser from \"tree-sitter\"\nimport PythonLanguage from \"tree-sitter-python\"\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 {requireSourceScalarType} from \"./scalars.js\"\n\nconst parser = new Parser()\n\nparser.setLanguage(/** @type {import(\"tree-sitter\").Language} */ (/** @type {unknown} */ (PythonLanguage)))\n\nconst immutableMarker = \"# @semantifold-immutable\"\nconst pythonReservedIdentifiers = new Set([\n  \"False\", \"None\", \"True\", \"and\", \"as\", \"assert\", \"async\", \"await\", \"break\", \"case\", \"class\", \"continue\",\n  \"def\", \"del\", \"elif\", \"else\", \"except\", \"exec\", \"finally\", \"for\", \"from\", \"global\", \"if\", \"import\", \"in\",\n  \"is\", \"lambda\", \"match\", \"nonlocal\", \"not\", \"or\", \"pass\", \"print\", \"raise\", \"return\", \"try\", \"type\",\n  \"while\", \"with\", \"yield\", \"_\", \"__debug__\", \"int\", \"bool\", \"str\"\n])\nconst binaryOperations = new Map([\n  [\"+\", \"Add\"],\n  [\"-\", \"Subtract\"],\n  [\"*\", \"Multiply\"]\n])\nconst comparisonOperations = new Map([\n  [\"==\", \"Equal\"],\n  [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"],\n  [\"<=\", \"LessThanOrEqual\"],\n  [\">\", \"GreaterThan\"],\n  [\">=\", \"GreaterThanOrEqual\"]\n])\n\n/** @typedef {{comments: import(\"tree-sitter\").SyntaxNode[], usedImmutableMarkers: Set<import(\"tree-sitter\").SyntaxNode>}} PythonContext */\n\n/**\n * Routes the binding's UTF-16 index through the shared UTF-8 byte converter.\n * node-tree-sitter parses JavaScript strings as UTF-16LE and exposes code-unit\n * indexes even though the grammar's native coordinate contract is byte-based.\n * @param {string} source - Complete source.\n * @param {number} index - Binding 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  const byteOffset = new TextEncoder().encode(source.slice(0, index)).length\n\n  return utf8ByteOffsetToUtf16Offset(source, byteOffset)\n}\n\n/**\n * Finds the first 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\n  return -1\n}\n\n/**\n * Converts a Tree-sitter byte range into Semantifold's UTF-16 coordinates.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Parser 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(\n    filename,\n    source,\n    bindingIndexToUtf16Offset(source, node.startIndex),\n    bindingIndexToUtf16Offset(source, node.endIndex)\n  )\n}\n\n/**\n * Requires one parser field.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Field owner.\n * @param {string} field - Grammar field name.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"tree-sitter\").SyntaxNode} Field node.\n */\nfunction requiredField(node, field, filename, source) {\n  const child = node.childForFieldName(field)\n\n  if (!child) return unsupportedSyntax(\"python\", `${node.type} without ${field}`, nodeLocation(node, filename, source))\n\n  return child\n}\n\n/**\n * Validates every named and anonymous parser child and rejects recovery.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Current parser 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.isError || node.isMissing) {\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\",\n      language: \"python\",\n      location: nodeLocation(node, filename, source),\n      message: `Tree-sitter exposed ${node.isMissing ? \"a missing\" : \"an error\"} recovery node '${node.type}'.`\n    })\n  }\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 * Rejects Python identifiers that cannot safely participate in the exact profile.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Identifier node.\n * @param {string} role - Diagnostic role.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {string} Accepted name.\n */\nfunction identifier(node, role, filename, source) {\n  const name = node.text\n\n  if (node.type != \"identifier\" || pythonReservedIdentifiers.has(name) || name.normalize(\"NFKC\") != name) {\n    return unsupportedSyntax(\"python\", `${role} identifier '${name}'`, nodeLocation(node, filename, source))\n  }\n\n  return name\n}\n\n/**\n * Converts one exact int/bool/str annotation.\n * @param {import(\"tree-sitter\").SyntaxNode | null} node - Type node, if present.\n * @param {string} subject - Typed subject.\n * @param {import(\"../semantic/types.js\").SourceLocation} ownerLocation - Owning declaration.\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(\"python\", subject, ownerLocation)\n  const typeLocation = nodeLocation(node, filename, source)\n  const children = node.namedChildren.filter((child) => child.type != \"comment\")\n\n  if (node.type != \"type\" || children.length != 1 || children[0].type != \"identifier\" ||\n    ![\"int\", \"bool\", \"str\"].includes(children[0].text) || node.text != children[0].text) {\n    return unsupportedSyntax(\"python\", \"unsupported scalar annotation\", typeLocation)\n  }\n\n  return requireSourceScalarType(\"python\", children[0].text, subject, ownerLocation, typeLocation)\n}\n\n/**\n * Finds exactly one anonymous operator token directly owned by a parser node.\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 tokens = node.children.filter((child) => !child.isNamed && spellings.has(child.type))\n\n  if (tokens.length != 1) return unsupportedSyntax(\"python\", `${node.type} operator`, nodeLocation(node, filename, source))\n\n  return tokens[0]\n}\n\n/**\n * Converts one supported Python 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 expressions = node.namedChildren.filter((child) => child.type != \"comment\")\n\n    if (expressions.length != 1) return unsupportedSyntax(\"python\", node.type, location)\n\n    return convertExpression(expressions[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 == \"integer\") {\n    let value\n\n    try {\n      value = Number(BigInt(node.text.replaceAll(\"_\", \"\")))\n    } catch {\n      return unsupportedSyntax(\"python\", \"integer literal\", location)\n    }\n    if (!Number.isSafeInteger(value)) return unsupportedSyntax(\"python\", \"non-safe integer literal\", location)\n\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 == \"string\") {\n    return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: decodeString(node, filename, source)}, {\n      literal: location\n    })\n  }\n  if (node.type == \"concatenated_string\") return unsupportedSyntax(\"python\", \"implicit string concatenation\", location)\n  if (node.type == \"unary_operator\") {\n    const operandNode = requiredField(node, \"argument\", filename, source)\n    const operator = operatorToken(node, new Set([\"-\"]), filename, source)\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand: convertExpression(operandNode, filename, source)\n    }, {operator: nodeLocation(operator, filename, source)}), \"Negate\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n  if (node.type == \"not_operator\") {\n    const operandNode = requiredField(node, \"argument\", filename, source)\n    const operator = operatorToken(node, new Set([\"not\"]), filename, source)\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand: convertExpression(operandNode, filename, source)\n    }, {operator: nodeLocation(operator, filename, source)}), \"Not\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n  if (node.type == \"binary_operator\" || node.type == \"comparison_operator\" || node.type == \"boolean_operator\") {\n    const expressionChildren = node.namedChildren.filter((child) => child.type != \"comment\")\n    const leftNode = node.childForFieldName(\"left\") ?? expressionChildren[0]\n    const rightNode = node.childForFieldName(\"right\") ?? expressionChildren[1]\n\n    if (!leftNode || !rightNode) return unsupportedSyntax(\"python\", node.type, location)\n    const operations = node.type == \"binary_operator\" ? binaryOperations : node.type == \"comparison_operator\"\n      ? comparisonOperations : new Map([[\"and\", \"And\"], [\"or\", \"Or\"]])\n    const operator = operatorToken(node, new Set(operations.keys()), filename, source)\n    const adapted = operations.get(operator.type)\n\n    if (!adapted || expressionChildren.length != 2) {\n      return unsupportedSyntax(\"python\", node.type, location)\n    }\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\",\n      left: convertExpression(leftNode, filename, source),\n      location,\n      right: convertExpression(rightNode, filename, source)\n    }, {operator: nodeLocation(operator, filename, source)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (adapted))\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n  if (node.type == \"call\") {\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\") {\n      return unsupportedSyntax(\"python\", \"dynamic call\", location)\n    }\n    const callee = identifier(calleeNode, \"callee\", filename, source)\n    const arguments_ = argumentsNode.namedChildren.filter((child) => child.type != \"comment\")\n      .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\n  return unsupportedSyntax(\"python\", node.type, location)\n}\n\n/**\n * Decodes one non-prefixed, non-triple Python string without evaluating source.\n * @param {import(\"tree-sitter\").SyntaxNode} node - String node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {string} Unicode scalar string.\n */\nfunction decodeString(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const text = node.text\n  const quote = text[0]\n\n  if ((quote != \"\\\"\" && quote != \"'\") || text.at(-1) != quote || text.startsWith(`${quote}${quote}${quote}`)) {\n    return unsupportedSyntax(\"python\", \"prefixed or triple-quoted string\", location)\n  }\n  let decoded = \"\"\n\n  for (let index = 1; index < text.length - 1; index += 1) {\n    const character = text[index]\n\n    if (character != \"\\\\\") {\n      decoded += character\n      continue\n    }\n    const escape = text[++index]\n\n    if (escape === undefined) return unsupportedSyntax(\"python\", \"invalid string escape\", location)\n    const simple = new Map([\n      [\"\\\\\", \"\\\\\"], [\"'\", \"'\"], [\"\\\"\", \"\\\"\"], [\"a\", \"\\u0007\"], [\"b\", \"\\b\"], [\"f\", \"\\f\"], [\"n\", \"\\n\"],\n      [\"r\", \"\\r\"], [\"t\", \"\\t\"], [\"v\", \"\\v\"]\n    ])\n\n    if (simple.has(escape)) {\n      decoded += simple.get(escape)\n      continue\n    }\n    if (/[0-7]/u.test(escape)) {\n      let digits = escape\n\n      while (digits.length < 3 && /[0-7]/u.test(text[index + 1] ?? \"\")) digits += text[++index]\n      decoded += String.fromCodePoint(Number.parseInt(digits, 8))\n      continue\n    }\n    const widths = new Map([[\"x\", 2], [\"u\", 4], [\"U\", 8]])\n    const width = widths.get(escape)\n\n    if (!width) return unsupportedSyntax(\"python\", `unsupported string escape \\\\${escape}`, location)\n    const digits = text.slice(index + 1, index + 1 + width)\n    if (digits.length != width || !/^[0-9A-Fa-f]+$/u.test(digits)) return unsupportedSyntax(\"python\", \"invalid string escape\", location)\n    index += width\n    const codePoint = Number.parseInt(digits, 16)\n\n    if (codePoint > 0x10FFFF || codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n      return unsupportedSyntax(\"python\", \"invalid Unicode string escape\", location)\n    }\n    decoded += String.fromCodePoint(codePoint)\n  }\n\n  if (!hasOnlyUnicodeScalars(decoded)) return unsupportedSyntax(\"python\", \"invalid Unicode string literal\", location)\n\n  return decoded\n}\n\n/**\n * Converts one annotated assignment or plain assignment.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Assignment node.\n * @param {PythonContext} context - Comment association state.\n * @param {Set<string>} visible - Visible bindings in this lexical scope.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").LocalStatement} Semantic local statement.\n */\nfunction convertAssignment(node, context, visible, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const left = requiredField(node, \"left\", filename, source)\n  const right = requiredField(node, \"right\", filename, source)\n  const typeNode = node.childForFieldName(\"type\")\n\n  if (left.type != \"identifier\") return unsupportedSyntax(\"python\", \"non-identifier assignment target\", nodeLocation(left, filename, source))\n  const name = identifier(left, typeNode ? \"local\" : \"assignment target\", filename, source)\n  const nameLocation = nodeLocation(left, filename, source)\n  const operator = operatorToken(node, new Set([\"=\"]), filename, source)\n\n  if (!typeNode) {\n    if (!visible.has(name)) return missingType(\"python\", `Local '${name}'`, location)\n    const target = withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: nameLocation, name}, {name: nameLocation})\n\n    return withParserRanges({\n      expression: convertExpression(right, filename, source),\n      kind: /** @type {const} */ (\"AssignmentStatement\"),\n      location,\n      target\n    }, {operator: nodeLocation(operator, filename, source)})\n  }\n\n  const declaration = withParserRanges({\n    initializer: convertExpression(right, filename, source),\n    kind: /** @type {const} */ (\"LocalDeclaration\"),\n    location,\n    mutable: !takeImmutableMarker(node, context),\n    name,\n    type: convertType(typeNode, `Local '${name}'`, location, filename, source)\n  }, {name: nameLocation, operator: nodeLocation(operator, filename, source)})\n\n  visible.add(name)\n\n  return declaration\n}\n\n/**\n * Associates the exact immediately preceding immutable marker with a local.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Local assignment.\n * @param {PythonContext} context - Comment state.\n * @returns {boolean} Whether the local is 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.usedImmutableMarkers.add(marker)\n\n  return true\n}\n\n/**\n * Converts one statement.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Statement node.\n * @param {PythonContext} context - Comment state.\n * @param {Set<string>} visible - Visible bindings in this lexical scope.\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, visible, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type == \"return_statement\") {\n    const expressions = node.namedChildren.filter((child) => child.type != \"comment\")\n\n    if (expressions.length != 1) return unsupportedSyntax(\"python\", \"return without one expression\", location)\n\n    return {expression: convertExpression(expressions[0], filename, source), kind: \"ReturnStatement\", location}\n  }\n  if (node.type == \"if_statement\") return convertIf(node, context, visible, filename, source)\n  if (node.type == \"expression_statement\") {\n    const expressions = node.namedChildren.filter((child) => child.type != \"comment\")\n\n    if (expressions.length != 1) return unsupportedSyntax(\"python\", node.type, location)\n    if (expressions[0].type == \"assignment\") return convertAssignment(expressions[0], context, visible, filename, source)\n\n    return convertPrint(expressions[0], filename, source, location)\n  }\n\n  return unsupportedSyntax(\"python\", node.type, location)\n}\n\n/**\n * Converts the exact print(expression) statement.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Expression statement value.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Whole statement location.\n * @returns {import(\"../semantic/types.js\").PrintStatement} Print statement.\n */\nfunction convertPrint(node, filename, source, location) {\n  if (node.type != \"call\") return unsupportedSyntax(\"python\", \"entry expression other than print\", nodeLocation(node, filename, source))\n  const callee = requiredField(node, \"function\", filename, source)\n  const argumentsNode = requiredField(node, \"arguments\", filename, source)\n  const arguments_ = argumentsNode.namedChildren.filter((child) => child.type != \"comment\")\n\n  if (callee.type != \"identifier\" || callee.text != \"print\" || argumentsNode.type != \"argument_list\" || arguments_.length != 1) {\n    return unsupportedSyntax(\"python\", \"print call shape\", nodeLocation(node, filename, source))\n  }\n\n  return {expression: convertExpression(arguments_[0], filename, source), kind: \"PrintStatement\", location}\n}\n\n/**\n * Converts one if/elif/else node into nested semantic blocks.\n * @param {import(\"tree-sitter\").SyntaxNode} node - If or elif node.\n * @param {PythonContext} context - Comment state.\n * @param {Set<string>} visible - Visible bindings in this lexical scope.\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, context, visible, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const conditionNode = requiredField(node, \"condition\", filename, source)\n  const consequenceNode = requiredField(node, \"consequence\", filename, source)\n  const alternativeNodes = node.namedChildren.filter((_child, index) => node.fieldNameForNamedChild(index) == \"alternative\")\n  const alternate = convertAlternatives(alternativeNodes, context, new Set(visible), filename, source)\n\n  return {\n    ...(alternate ? {alternate} : {}),\n    condition: convertExpression(conditionNode, filename, source),\n    consequent: convertBlock(consequenceNode, context, new Set(visible), filename, source),\n    kind: \"IfStatement\",\n    location\n  }\n}\n\n/**\n * Converts an else block or nests one elif inside its semantic alternate block.\n * @param {import(\"tree-sitter\").SyntaxNode[]} nodes - Ordered elif/else nodes.\n * @param {PythonContext} context - Comment state.\n * @param {Set<string>} visible - Visible bindings in this lexical scope.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Block | undefined} Alternate block.\n */\nfunction convertAlternatives(nodes, context, visible, filename, source) {\n  /** @type {import(\"../semantic/types.js\").Block | undefined} */\n  let alternate\n\n  for (let index = nodes.length - 1; index >= 0; index -= 1) {\n    const node = nodes[index]\n\n    if (node.type == \"else_clause\") {\n      if (alternate) return unsupportedSyntax(\"python\", \"multiple else clauses\", nodeLocation(node, filename, source))\n      alternate = convertBlock(requiredField(node, \"body\", filename, source), context, new Set(visible), filename, source)\n      continue\n    }\n    if (node.type != \"elif_clause\") return unsupportedSyntax(\"python\", node.type, nodeLocation(node, filename, source))\n    const nested = convertIf(node, context, new Set(visible), filename, source)\n\n    if (alternate) nested.alternate = alternate\n    alternate = {kind: \"Block\", location: nodeLocation(node, filename, source), statements: [nested]}\n  }\n\n  return alternate\n}\n\n/**\n * Converts one indentation block and permits pass only as its sole executable node.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Block node.\n * @param {PythonContext} context - Comment state.\n * @param {Set<string>} visible - Visible bindings in this lexical scope.\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, visible, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type != \"block\") return unsupportedSyntax(\"python\", node.type, location)\n  const statements = node.namedChildren.filter((child) => child.type != \"comment\")\n\n  if (statements.some((statement) => statement.type == \"pass_statement\")) {\n    if (statements.length != 1) return unsupportedSyntax(\"python\", \"pass with executable siblings\", location)\n\n    return {kind: \"Block\", location, statements: []}\n  }\n\n  return {kind: \"Block\", location, statements: statements.map((statement) => convertStatement(statement, context, visible, filename, source))}\n}\n\n/**\n * Converts one exact synchronous top-level function.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Function node.\n * @param {PythonContext} context - Comment state.\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, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type != \"function_definition\" || node.children.some((child) => !child.isNamed && child.type == \"async\")) {\n    return unsupportedSyntax(\"python\", node.type, location)\n  }\n  const typeParametersNode = node.childForFieldName(\"type_parameters\")\n\n  if (typeParametersNode) {\n    return unsupportedSyntax(\"python\", typeParametersNode.type, nodeLocation(typeParametersNode, filename, source))\n  }\n  const nameNode = requiredField(node, \"name\", filename, source)\n  const parametersNode = requiredField(node, \"parameters\", filename, source)\n  const returnNode = node.childForFieldName(\"return_type\")\n  const bodyNode = requiredField(node, \"body\", filename, source)\n  const name = identifier(nameNode, \"function\", filename, source)\n  const parameterNodes = parametersNode.namedChildren.filter((child) => child.type != \"comment\")\n\n  if (parametersNode.children.some((child) => !child.isNamed && ![\"(\", \")\", \",\"].includes(child.type))) {\n    return unsupportedSyntax(\"python\", \"parameter separators\", nodeLocation(parametersNode, filename, source))\n  }\n  const parameters = parameterNodes.map((parameterNode) => {\n    const parameterLocation = nodeLocation(parameterNode, filename, source)\n\n    if (parameterNode.type != \"typed_parameter\") {\n      if (parameterNode.type == \"identifier\") return missingType(\"python\", `Parameter '${parameterNode.text}'`, parameterLocation)\n\n      return unsupportedSyntax(\"python\", parameterNode.type, parameterLocation)\n    }\n    const parameterNameNode = parameterNode.namedChildren.find((child) => child.type == \"identifier\")\n    const typeNode = parameterNode.childForFieldName(\"type\")\n\n    if (!parameterNameNode) return unsupportedSyntax(\"python\", \"parameter without identifier\", parameterLocation)\n    const parameterName = identifier(parameterNameNode, \"parameter\", filename, source)\n\n    return withParserRanges({\n      kind: /** @type {const} */ (\"Parameter\"),\n      location: parameterLocation,\n      name: parameterName,\n      type: convertType(typeNode, `Parameter '${parameterName}'`, parameterLocation, filename, source)\n    }, {name: nodeLocation(parameterNameNode, filename, source)})\n  })\n\n  const visible = new Set(parameters.map((parameter) => parameter.name))\n\n  return withParserRanges({\n    body: convertBlock(bodyNode, context, visible, filename, source),\n    kind: \"FunctionDeclaration\",\n    location,\n    name,\n    parameters,\n    returnType: convertType(returnNode, `Function '${name}' return`, location, filename, source)\n  }, {name: nodeLocation(nameNode, filename, source)})\n}\n\n/**\n * Parses the strict Task 016 Python profile.\n * @param {{filename: string, source: string}} input - Parser input.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parsePython({filename, source}) {\n  if (!hasOnlyUnicodeScalars(source)) {\n    const invalidOffset = firstLoneSurrogateOffset(source)\n\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\",\n      language: \"python\",\n      location: locationFromOffsets(filename, source, invalidOffset, invalidOffset + 1),\n      message: \"Python 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(\"python\", error)\n  }\n  const root = tree.rootNode\n\n  validateParserTree(root, filename, source)\n  if (root.type != \"module\") throw new Error(`Tree-sitter returned Python root '${root.type}'.`)\n\n  const comments = root.descendantsOfType(\"comment\")\n  const context = {comments, usedImmutableMarkers: new Set()}\n  const functions = []\n  const entryNodes = []\n  let sawEntry = false\n\n  for (const node of root.namedChildren) {\n    if (node.type == \"comment\") continue\n    if (node.type == \"function_definition\" && !sawEntry) functions.push(convertFunction(node, context, filename, source))\n    else {\n      sawEntry = true\n      entryNodes.push(node)\n    }\n  }\n  const location = moduleLocation(filename, source)\n  const entryLocation = entryNodes.length == 0 ? location : locationFromOffsets(\n    filename,\n    source,\n    bindingIndexToUtf16Offset(source, entryNodes[0].startIndex),\n    bindingIndexToUtf16Offset(source, entryNodes.at(-1)?.endIndex ?? root.endIndex)\n  )\n  const entryVisible = new Set()\n  const entryHasPass = entryNodes.some((node) => node.type == \"pass_statement\")\n\n  if (entryHasPass && entryNodes.length != 1) {\n    return unsupportedSyntax(\"python\", \"top-level pass with executable siblings\", entryLocation)\n  }\n  const entryBlock = {\n    kind: /** @type {const} */ (\"Block\"),\n    location: entryLocation,\n    statements: entryHasPass ? [] : entryNodes.map((node) => convertStatement(node, context, entryVisible, filename, source))\n  }\n  const unusedMarker = comments.find((comment) => comment.text == immutableMarker && !context.usedImmutableMarkers.has(comment))\n\n  if (unusedMarker) return unsupportedSyntax(\"python\", \"unattached immutable marker\", nodeLocation(unusedMarker, filename, source))\n  if (functions.length == 0) return unsupportedSyntax(\"python\", \"module without a function\", location)\n\n  return {\n    entryPoint: {body: entryBlock, kind: \"EntryPoint\", location: entryLocation},\n    functions,\n    kind: \"Module\",\n    location\n  }\n}\n"]}