semantifold 0.3.0 → 0.4.0

package/build/src/frontends/dart.js

@@ -0,0 +1,913 @@
+// @ts-check
+import Parser from "tree-sitter";
+import DartLanguage from "tree-sitter-dart-orchard/bindings/node/index.js";
+import { isDartIdentifier } from "../backends/identifiers.js";
+import { dartRuntime } from "../backends/dart-runtime.js";
+import { missingType, SemantifoldDiagnostic, unsupportedSyntax } from "../diagnostic.js";
+import { locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset } from "../semantic/location.js";
+import { withAdaptedOperation } from "../semantic/operators.js";
+import { withParserRanges } from "../semantic/provenance.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { validateParsedModule } from "../semantic/validate.js";
+import { sourceScalarType } from "./scalars.js";
+const parser = new Parser();
+parser.setLanguage(/** @type {import("tree-sitter").Language} */ ( /** @type {unknown} */(DartLanguage)));
+const binaryOperations = new Map([
+    ["+", "Add"], ["-", "Subtract"], ["*", "Multiply"], ["==", "Equal"], ["!=", "NotEqual"],
+    ["<", "LessThan"], ["<=", "LessThanOrEqual"], [">", "GreaterThan"], [">=", "GreaterThanOrEqual"],
+    ["&&", "And"], ["||", "Or"]
+]);
+/** @type {Map<string, readonly [string, Set<string>]>} */
+const binaryNodeOperators = new Map([
+    ["additive_expression", ["additive_operator", new Set(["+", "-"])]],
+    ["multiplicative_expression", ["multiplicative_operator", new Set(["*"])]],
+    ["equality_expression", ["equality_operator", new Set(["==", "!="])]],
+    ["relational_expression", ["relational_operator", new Set(["<", "<=", ">", ">="])]],
+    ["logical_and_expression", ["logical_and_operator", new Set(["&&"])]],
+    ["logical_or_expression", ["logical_or_operator", new Set(["||"])]]
+]);
+const commentTypes = new Set(["comment", "documentation_comment"]);
+/** @type {Map<string, import("../semantic/operators.js").AdaptedOperation>} */
+const helperOperations = new Map([
+    ["_semantifoldIntegerAdd", "Add"], ["_semantifoldIntegerSubtract", "Subtract"],
+    ["_semantifoldIntegerMultiply", "Multiply"], ["_semantifoldIntegerNegate", "Negate"]
+]);
+/**
+ * Verifies a binding-reported UTF-16 index through the shared UTF-8 converter.
+ * @param {string} source Complete source.
+ * @param {number} index Binding 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 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;
+}
+/** Consumes exact qualified Dart CST shapes without retaining parser values. */
+class DartReader {
+    /**
+     * Creates a reader bound to one exact Dart source unit.
+     * @param {string} filename Original filename.
+     * @param {string} source Complete source.
+     */
+    constructor(filename, source) {
+        this.filename = filename;
+        this.source = source;
+        /** @type {Set<string>} */
+        this.functionNames = new Set();
+        this.runtime = false;
+    }
+    /**
+     * Builds a semantic source location from one parser node.
+     * @param {import("tree-sitter").SyntaxNode} node Parser node.
+     * @returns {import("../semantic/types.js").SourceLocation} Exact location.
+     */
+    location(node) {
+        return locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, node.startIndex), bindingIndexToUtf16Offset(this.source, node.endIndex));
+    }
+    /**
+     * Rejects one parser node with a located unsupported-syntax diagnostic.
+     * @param {import("tree-sitter").SyntaxNode} node Violating node.
+     * @param {string} [detail] Profile detail.
+     * @returns {never} Always throws.
+     */
+    fail(node, detail = node.type) {
+        unsupportedSyntax("dart", detail, this.location(node));
+    }
+    /**
+     * Traverses every named, anonymous, extra, field, and recovery edge.
+     * @param {import("tree-sitter").SyntaxNode} root Complete parser root.
+     * @returns {void}
+     */
+    validateTree(root) {
+        const pending = [{ depth: 0, node: root, visited: false }];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (!current)
+                throw new Error("Dart traversal lost a pending parser node.");
+            const { depth, node, visited } = current;
+            if (depth > 512)
+                this.fail(node, "CST exceeds the 512-level traversal limit");
+            if (!visited) {
+                pending.push({ depth, node, visited: true });
+                for (let index = node.childCount - 1; index >= 0; index -= 1) {
+                    const child = node.child(index);
+                    if (!child)
+                        throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`);
+                    node.fieldNameForChild(index);
+                    pending.push({ depth: depth + 1, node: child, visited: false });
+                }
+                continue;
+            }
+            if (node.hasError || node.isError || node.isMissing) {
+                throw new SemantifoldDiagnostic({
+                    code: "PARSE_ERROR",
+                    language: "dart",
+                    location: this.location(node),
+                    message: `Tree-sitter exposed recovery at '${node.type}'.`
+                });
+            }
+            if (["annotation", "import_or_export", "library_name", "part_header", "part_of_header"].includes(node.type)) {
+                this.fail(node, node.type);
+            }
+            if (commentTypes.has(node.type) && (/(?:@dart\s*=|dartfmt|ignore(?:_for_file)?\s*:|language[-_ ]version)/iu.test(node.text) ||
+                /^\/\/ dart format (?:off|on)[\t ]*$/u.test(node.text))) {
+                this.fail(node, "directive-bearing comment");
+            }
+        }
+    }
+    /**
+     * Omits only ordinary comments already covered by exhaustive traversal.
+     * @param {import("tree-sitter").SyntaxNode} node Parent node.
+     * @returns {import("tree-sitter").SyntaxNode[]} Structural children.
+     */
+    parts(node) {
+        return node.children.filter((child) => !commentTypes.has(child.type));
+    }
+    /**
+     * Verifies an exact structural child sequence.
+     * @param {import("tree-sitter").SyntaxNode} node Shape owner.
+     * @param {(import("tree-sitter").SyntaxNode | string)[]} expected Exact child sequence.
+     * @returns {void}
+     */
+    shape(node, expected) {
+        const actual = this.parts(node);
+        if (actual.length != expected.length)
+            this.fail(actual[Math.min(actual.length, expected.length)] ?? node, `${node.type} child shape`);
+        for (let index = 0; index < expected.length; index += 1) {
+            const wanted = expected[index];
+            const child = actual[index];
+            const matches = typeof wanted == "string" ? child.text == wanted : child.id == wanted.id;
+            if (!matches)
+                this.fail(child, `${node.type} child shape`);
+        }
+    }
+    /**
+     * Consumes an Orchard operator wrapper whether its token is aliased into the wrapper or exposed anonymously.
+     * @param {import("tree-sitter").SyntaxNode} node Operator node.
+     * @returns {void}
+     */
+    operatorShape(node) {
+        const parts = this.parts(node);
+        if (parts.length > 1 || parts.length == 1 && (parts[0].isNamed || parts[0].text != node.text)) {
+            this.fail(node, `${node.type} child shape`);
+        }
+        this.shape(node, parts.length == 0 ? [] : [node.text]);
+    }
+    /**
+     * Returns exactly one parser child carrying a requested field name.
+     * @param {import("tree-sitter").SyntaxNode} node Field owner.
+     * @param {string} name Field name.
+     * @returns {import("tree-sitter").SyntaxNode} Sole field node.
+     */
+    field(node, name) {
+        const matches = [];
+        for (let index = 0; index < node.childCount; index += 1) {
+            const child = node.child(index);
+            if (!child)
+                throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`);
+            if (node.fieldNameForChild(index) == name)
+                matches.push(child);
+        }
+        if (matches.length != 1)
+            this.fail(node, `expected one '${name}' field`);
+        return matches[0];
+    }
+    /**
+     * Validates and returns a source identifier.
+     * @param {import("tree-sitter").SyntaxNode} node Identifier token.
+     * @param {boolean} [allowMain] Whether fixed main is expected.
+     * @param {boolean} [allowPrint] Whether fixed print is expected.
+     * @returns {string} Accepted name.
+     */
+    identifier(node, allowMain = false, allowPrint = false) {
+        const name = node.text;
+        if (node.type != "identifier" || !(allowMain && name == "main") && !(allowPrint && name == "print") &&
+            !isDartIdentifier(name))
+            this.fail(node, "reserved or unsupported identifier");
+        return name;
+    }
+    /**
+     * Converts one explicitly named scalar type.
+     * @param {import("tree-sitter").SyntaxNode} node Type node.
+     * @returns {import("../semantic/types.js").TypeReference} Scalar type.
+     */
+    scalarType(node) {
+        if (node.type != "type_identifier" || this.parts(node).length != 0)
+            this.fail(node, "scalar type shape");
+        const type = sourceScalarType("dart", node.text, this.location(node));
+        if (!type)
+            this.fail(node, `unsupported scalar type '${node.text}'`);
+        return type;
+    }
+    /**
+     * Converts one explicit scalar or void result type.
+     * @param {import("tree-sitter").SyntaxNode} node Return type node.
+     * @returns {import("../semantic/types.js").SemanticFunctionReturnType} Function return type.
+     */
+    returnType(node) {
+        if (node.type == "void_type") {
+            const parts = this.parts(node);
+            if (node.text != "void" || parts.length > 1 || parts.length == 1 && parts[0].text != "void") {
+                this.fail(node, "void type shape");
+            }
+            this.shape(node, parts);
+            const type = { kind: /** @type {const} */ ("TypeReference"), name: /** @type {const} */ ("void") };
+            return withParserRanges(type, { type: this.location(node) });
+        }
+        return this.scalarType(node);
+    }
+    /**
+     * Decodes one ordinary noninterpolated, non-raw, single-line Dart string.
+     * @param {import("tree-sitter").SyntaxNode} node String node.
+     * @returns {string} Decoded Unicode scalar value.
+     */
+    string(node) {
+        const parts = this.parts(node);
+        const delimiter = node.text[0];
+        if (node.type != "string_literal" || !["\"", "'"].includes(delimiter) || node.text.startsWith(delimiter.repeat(3)) ||
+            node.text.at(-1) != delimiter || parts.length < 2 || parts[0].text != delimiter || parts.at(-1)?.text != delimiter ||
+            parts.slice(1, -1).some(({ type }) => type != "escape_sequence")) {
+            this.fail(node, "ordinary noninterpolated string literal required");
+        }
+        this.shape(node, parts);
+        const source = node.text.slice(1, -1);
+        const simpleEscapes = new Map([
+            ["b", "\b"], ["f", "\f"], ["n", "\n"], ["r", "\r"], ["t", "\t"], ["v", "\v"],
+            ["$", "$"], ["'", "'"], ['"', '"'], ["\\", "\\"]
+        ]);
+        let value = "";
+        for (let index = 0; index < source.length; index += 1) {
+            const character = source[index];
+            if (character != "\\") {
+                if (character == "\n" || character == "\r" || character == delimiter || character == "$") {
+                    this.fail(node, "invalid or interpolated string content");
+                }
+                value += character;
+                continue;
+            }
+            const escaped = source[++index];
+            if (simpleEscapes.has(escaped))
+                value += simpleEscapes.get(escaped);
+            else if (escaped == "x") {
+                const hexadecimal = source.slice(index + 1, index + 3);
+                if (!/^[0-9A-Fa-f]{2}$/u.test(hexadecimal))
+                    this.fail(node, "unsupported string escape");
+                value += String.fromCodePoint(Number.parseInt(hexadecimal, 16));
+                index += 2;
+            }
+            else if (escaped == "u") {
+                if (source[index + 1] == "{") {
+                    const closing = source.indexOf("}", index + 2);
+                    const hexadecimal = closing < 0 ? "" : source.slice(index + 2, closing);
+                    const codePoint = /^[0-9A-Fa-f]{1,6}$/u.test(hexadecimal) ? Number.parseInt(hexadecimal, 16) : -1;
+                    if (codePoint < 0 || codePoint > 0x10FFFF)
+                        this.fail(node, "unsupported string escape");
+                    value += String.fromCodePoint(codePoint);
+                    index = closing;
+                }
+                else {
+                    const hexadecimal = source.slice(index + 1, index + 5);
+                    if (!/^[0-9A-Fa-f]{4}$/u.test(hexadecimal))
+                        this.fail(node, "unsupported string escape");
+                    value += String.fromCharCode(Number.parseInt(hexadecimal, 16));
+                    index += 4;
+                }
+            }
+            else
+                this.fail(node, "unsupported string escape");
+        }
+        if (!hasOnlyUnicodeScalars(value))
+            this.fail(node, "invalid Unicode string literal");
+        return value;
+    }
+    /**
+     * Extracts exact required positional arguments.
+     * @param {import("tree-sitter").SyntaxNode} part Call argument part.
+     * @returns {import("tree-sitter").SyntaxNode[][]} Argument expression edges.
+     */
+    arguments(part) {
+        const partChildren = this.parts(part);
+        if (part.type != "argument_part" || partChildren.length != 1 || partChildren[0].type != "arguments") {
+            this.fail(part, "call argument part shape");
+        }
+        this.shape(part, [partChildren[0]]);
+        const list = partChildren[0];
+        const listParts = this.parts(list);
+        if (listParts.length < 2 || listParts[0].text != "(" || listParts.at(-1)?.text != ")") {
+            this.fail(list, "call argument list shape");
+        }
+        const interior = listParts.slice(1, -1);
+        const hasGeneratedTrailingComma = this.runtime && interior.at(-1)?.text == ",";
+        const argumentParts = hasGeneratedTrailingComma ? interior.slice(0, -1) : interior;
+        const arguments_ = argumentParts.filter((_child, index) => index % 2 == 0);
+        this.shape(list, ["(", ...arguments_.flatMap((argument, index) => index ? [",", argument] : [argument]),
+            ...(hasGeneratedTrailingComma ? [","] : []), ")"]);
+        return arguments_.map((argument) => {
+            if (argument.type != "argument")
+                this.fail(argument, "required positional argument");
+            const expressionParts = this.parts(argument);
+            if (expressionParts.length == 0)
+                this.fail(argument, "empty argument");
+            return expressionParts;
+        });
+    }
+    /**
+     * Converts one direct method-invocation node whose function is a plain identifier.
+     * @param {import("tree-sitter").SyntaxNode[]} nodes Exact one-node call.
+     * @param {import("tree-sitter").SyntaxNode} owner Expression owner.
+     * @param {boolean} [allowPrint] Whether this is the print scaffold.
+     * @returns {import("../semantic/types.js").Expression} Semantic call or private generated operation.
+     */
+    call(nodes, owner, allowPrint = false) {
+        if (nodes.length != 1 || nodes[0].type != "method_invocation") {
+            this.fail(nodes[0] ?? owner, "direct call shape");
+        }
+        const invocation = nodes[0];
+        const parts = this.parts(invocation);
+        const functionNode = this.field(invocation, "function");
+        const argumentPart = this.field(invocation, "arguments");
+        if (parts.length != 2 || parts[0].id != functionNode.id || functionNode.type != "identifier" ||
+            parts[1].id != argumentPart.id || argumentPart.type != "argument_part")
+            this.fail(invocation, "direct call shape");
+        this.shape(invocation, [functionNode, argumentPart]);
+        const name = functionNode.text;
+        const helper = this.runtime ? helperOperations.get(name) : undefined;
+        const location = this.location(invocation);
+        const argumentNodes = this.arguments(argumentPart);
+        if (this.runtime && name == "_semantifoldBoolean") {
+            if (argumentNodes.length != 1)
+                this.fail(argumentPart, "Dart Boolean literal helper shape");
+            const literal = this.expression(argumentNodes[0], owner);
+            if (literal.kind != "BooleanLiteral")
+                this.fail(argumentPart, "Dart Boolean literal helper shape");
+            return literal;
+        }
+        if (helper) {
+            const count = helper == "Negate" ? 1 : 2;
+            if (argumentNodes.length != count)
+                this.fail(argumentPart, "Dart checked-integer helper shape");
+            if (helper == "Negate") {
+                return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+                    kind: /** @type {const} */ ("UnaryExpression"), location,
+                    operand: this.expression(argumentNodes[0], owner)
+                }, { operator: this.location(functionNode) }), helper)));
+            }
+            return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+                kind: /** @type {const} */ ("BinaryExpression"), left: this.expression(argumentNodes[0], owner), location,
+                right: this.expression(argumentNodes[1], owner)
+            }, { operator: this.location(functionNode) }), helper)));
+        }
+        this.identifier(functionNode, false, allowPrint);
+        return withParserRanges({
+            arguments: argumentNodes.map((argument) => this.expression(argument, owner)),
+            callee: name,
+            kind: /** @type {const} */ ("CallExpression"),
+            location
+        }, { callee: this.location(functionNode) });
+    }
+    /**
+     * Recursively compares one source support subtree with the canonical runtime CST.
+     * @param {import("tree-sitter").SyntaxNode} actual Source node.
+     * @param {import("tree-sitter").SyntaxNode} expected Canonical node.
+     * @returns {void}
+     */
+    compareTree(actual, expected) {
+        if (actual.type != expected.type || actual.isNamed != expected.isNamed || actual.isExtra != expected.isExtra ||
+            actual.childCount != expected.childCount)
+            this.fail(actual, "modified Dart support node");
+        if (actual.childCount == 0 && actual.text != expected.text)
+            this.fail(actual, "modified Dart support token");
+        for (let index = 0; index < actual.childCount; index += 1) {
+            const left = actual.child(index);
+            const right = expected.child(index);
+            if (!left || !right || actual.fieldNameForChild(index) != expected.fieldNameForChild(index)) {
+                this.fail(left ?? actual, "modified Dart support field");
+            }
+            this.compareTree(left, right);
+        }
+    }
+    /**
+     * Converts an expression represented by one or more adjacent Dart CST nodes.
+     * @param {import("tree-sitter").SyntaxNode[]} nodes Expression nodes.
+     * @param {import("tree-sitter").SyntaxNode} owner Owning node.
+     * @returns {import("../semantic/types.js").Expression} Semantic expression.
+     */
+    expression(nodes, owner) {
+        if (nodes.length == 1 && nodes[0].type == "method_invocation")
+            return this.call(nodes, owner);
+        if (nodes.length != 1)
+            return this.fail(nodes[0] ?? owner, "scalar expression shape");
+        const node = nodes[0];
+        const location = this.location(node);
+        if (node.type == "identifier") {
+            const name = this.identifier(node);
+            if (this.functionNames.has(name))
+                this.fail(node, "function tear-off");
+            return withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location, name }, { name: location });
+        }
+        if (node.type == "decimal_integer_literal") {
+            if (this.parts(node).length != 0 || !/^(?:0|[1-9][0-9]*)$/u.test(node.text))
+                this.fail(node, "noncanonical integer literal");
+            const value = Number(BigInt(node.text));
+            if (!Number.isSafeInteger(value))
+                this.fail(node, "non-safe integer literal");
+            return withParserRanges({ kind: /** @type {const} */ ("IntegerLiteral"), location, value }, { literal: location });
+        }
+        if (node.type == "true" || node.type == "false") {
+            this.shape(node, [node.type]);
+            return withParserRanges({ kind: /** @type {const} */ ("BooleanLiteral"), location, value: node.type == "true" }, { literal: location });
+        }
+        if (node.type == "string_literal") {
+            return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: this.string(node) }, { literal: location });
+        }
+        if (node.type == "parenthesized_expression") {
+            const parts = this.parts(node);
+            if (parts.length < 3 || parts[0].text != "(" || parts.at(-1)?.text != ")")
+                this.fail(node, "parenthesized expression shape");
+            this.shape(node, ["(", ...parts.slice(1, -1), ")"]);
+            return this.expression(parts.slice(1, -1), node);
+        }
+        if (node.type == "unary_expression") {
+            const parts = this.parts(node);
+            const operator = parts[0];
+            if (parts.length < 2 || operator.type != "prefix_operator" || !["-", "!"].includes(operator.text)) {
+                this.fail(node, "unary operator");
+            }
+            const operatorParts = this.parts(operator);
+            if (operatorParts.length != 1 || operatorParts[0].text != operator.text ||
+                !["minus_operator", "negation_operator"].includes(operatorParts[0].type))
+                this.fail(operator, "unary operator shape");
+            this.operatorShape(operatorParts[0]);
+            this.shape(node, [operator, ...parts.slice(1)]);
+            return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+                kind: /** @type {const} */ ("UnaryExpression"),
+                location,
+                operand: this.expression(parts.slice(1), node)
+            }, { operator: this.location(operator) }), operator.text == "-" ? "Negate" : "Not")));
+        }
+        if (binaryNodeOperators.has(node.type))
+            return this.binary(node);
+        return this.fail(node);
+    }
+    /**
+     * Converts a bounded binary expression tree.
+     * @param {import("tree-sitter").SyntaxNode} node Binary expression node.
+     * @returns {import("../semantic/types.js").Expression} Semantic binary expression.
+     */
+    binary(node) {
+        /** @type {import("tree-sitter").SyntaxNode[][]} */
+        const operands = [];
+        /** @type {import("tree-sitter").SyntaxNode[]} */
+        const operators = [];
+        let current = node;
+        while (true) {
+            const parts = this.parts(current);
+            const declaration = binaryNodeOperators.get(current.type);
+            const operatorType = declaration?.[0];
+            const accepted = declaration?.[1];
+            const operatorIndexes = parts.flatMap((part, index) => part.type == operatorType ? [index] : []);
+            if (operatorIndexes.length != 1)
+                this.fail(current, `${current.type} child shape`);
+            const operatorIndex = operatorIndexes[0];
+            const operator = parts[operatorIndex];
+            if (operatorIndex == 0 || operatorIndex == parts.length - 1 || !accepted?.has(operator.text) ||
+                !binaryOperations.has(operator.text))
+                this.fail(operator, "unsupported binary operator");
+            this.operatorShape(operator);
+            this.shape(current, parts);
+            operands.push(parts.slice(0, operatorIndex));
+            operators.push(operator);
+            const right = parts.slice(operatorIndex + 1);
+            if (right.length == 1 && right[0].type == node.type)
+                current = right[0];
+            else {
+                operands.push(right);
+                break;
+            }
+        }
+        let expression = this.expression(operands[0], node);
+        for (let index = 0; index < operators.length; index += 1) {
+            const operator = operators[index];
+            const operation = binaryOperations.get(operator.text);
+            const right = this.expression(operands[index + 1], node);
+            const first = operands[0][0];
+            const last = operands[index + 1].at(-1);
+            const location = first && last
+                ? locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, first.startIndex), bindingIndexToUtf16Offset(this.source, last.endIndex))
+                : this.location(node);
+            expression = /** @type {import("../semantic/types.js").Expression} */ (withAdaptedOperation(withParserRanges({
+                kind: /** @type {const} */ ("BinaryExpression"), left: expression, location, right
+            }, { operator: this.location(operator) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (operation)));
+        }
+        return expression;
+    }
+    /**
+     * Converts one explicitly typed initialized local declaration.
+     * @param {import("tree-sitter").SyntaxNode} node Local declaration.
+     * @returns {import("../semantic/types.js").LocalDeclaration} Semantic local.
+     */
+    local(node) {
+        const declarationParts = this.parts(node);
+        if (node.type != "local_variable_declaration" || declarationParts.length != 2 ||
+            declarationParts[0].type != "initialized_variable_definition" || declarationParts[1].text != ";") {
+            this.fail(node, "local declaration shape");
+        }
+        this.shape(node, [declarationParts[0], ";"]);
+        const definition = declarationParts[0];
+        const parts = this.parts(definition);
+        if (parts[0]?.type == "inferred_type" || parts[0]?.type == "final_builtin" && parts[1]?.type == "identifier") {
+            return missingType("dart", "Local", this.location(definition));
+        }
+        const immutable = parts[0]?.type == "final_builtin";
+        const typeIndex = immutable ? 1 : 0;
+        const typeNode = parts[typeIndex];
+        const nameNode = parts[typeIndex + 1];
+        const equals = parts[typeIndex + 2];
+        const expressionParts = parts.slice(typeIndex + 3);
+        if (parts.length < typeIndex + 4 || typeNode?.type != "type_identifier" || nameNode?.type != "identifier" ||
+            equals?.text != "=" || expressionParts.length == 0 || immutable && parts[0].text != "final") {
+            this.fail(parts[0] ?? definition, "explicitly typed initialized local required");
+        }
+        this.shape(definition, [...(immutable ? [parts[0]] : []), typeNode, nameNode, "=", ...expressionParts]);
+        if (this.field(definition, "name").id != nameNode.id)
+            this.fail(nameNode, "local name field");
+        const name = this.identifier(nameNode);
+        return withParserRanges({
+            initializer: this.expression(expressionParts, definition),
+            kind: /** @type {const} */ ("LocalDeclaration"),
+            location: this.location(node),
+            mutable: !immutable,
+            name,
+            type: this.scalarType(typeNode)
+        }, { name: this.location(nameNode), operator: this.location(equals) });
+    }
+    /**
+     * Converts one simple identifier assignment.
+     * @param {import("tree-sitter").SyntaxNode} node Assignment expression.
+     * @returns {import("../semantic/types.js").AssignmentStatement} Semantic assignment.
+     */
+    assignment(node) {
+        const parts = this.parts(node);
+        const target = parts[0];
+        const operator = parts[1];
+        if (node.type != "assignment_expression" || parts.length < 3 || target?.type != "assignable_expression" ||
+            operator?.type != "assignment_operator" || operator.text != "=")
+            this.fail(node, "simple assignment shape");
+        const targetParts = this.parts(target);
+        if (targetParts.length != 1 || targetParts[0].type != "identifier")
+            this.fail(target, "simple assignment target");
+        this.shape(target, [targetParts[0]]);
+        this.operatorShape(operator);
+        this.shape(node, [target, "=", ...parts.slice(2)]);
+        const name = this.identifier(targetParts[0]);
+        const targetLocation = this.location(targetParts[0]);
+        return withParserRanges({
+            expression: this.expression(parts.slice(2), node),
+            kind: /** @type {const} */ ("AssignmentStatement"),
+            location: this.location(node),
+            target: withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: targetLocation, name }, { name: targetLocation })
+        }, { operator: this.location(operator) });
+    }
+    /**
+     * Converts one supported Dart statement.
+     * @param {import("tree-sitter").SyntaxNode} node Source statement.
+     * @returns {import("../semantic/types.js").Statement} Semantic statement.
+     */
+    statement(node) {
+        if (node.type == "local_variable_declaration")
+            return this.local(node);
+        if (node.type == "if_statement")
+            return this.conditional(node);
+        if (node.type == "return_statement") {
+            const parts = this.parts(node);
+            if (parts.length < 2 || parts[0].text != "return" || parts.at(-1)?.text != ";")
+                this.fail(node, "return statement shape");
+            this.shape(node, ["return", ...parts.slice(1, -1), ";"]);
+            const expressionParts = parts.slice(1, -1);
+            return {
+                ...(expressionParts.length > 0 ? { expression: this.expression(expressionParts, node) } : {}),
+                kind: /** @type {const} */ ("ReturnStatement"),
+                location: this.location(node)
+            };
+        }
+        if (node.type == "expression_statement") {
+            const parts = this.parts(node);
+            if (parts.length < 2 || parts.at(-1)?.text != ";")
+                this.fail(node, "expression statement shape");
+            this.shape(node, [...parts.slice(0, -1), ";"]);
+            if (parts.length == 2 && parts[0].type == "assignment_expression")
+                return this.assignment(parts[0]);
+            const callParts = parts.slice(0, -1);
+            const callChildren = callParts.length == 1 && callParts[0].type == "method_invocation"
+                ? this.parts(callParts[0]) : [];
+            const print = callChildren[0]?.type == "identifier" && callChildren[0].text == "print";
+            const expression = this.call(callParts, node, print);
+            if (print) {
+                if (expression.kind != "CallExpression" || expression.arguments.length != 1) {
+                    this.fail(callParts[0], "print argument count");
+                }
+                return { expression: expression.arguments[0], kind: /** @type {const} */ ("PrintStatement"), location: this.location(node) };
+            }
+            if (expression.kind != "CallExpression")
+                this.fail(callParts[0], "generated helper expression statement");
+            return { expression, kind: /** @type {const} */ ("ExpressionStatement"), location: this.location(node) };
+        }
+        return this.fail(node);
+    }
+    /**
+     * Consumes one compiler-owned read that prevents Dart from rejecting an otherwise unread local.
+     * @param {import("tree-sitter").SyntaxNode} node Candidate source statement.
+     * @param {import("../semantic/types.js").Statement | undefined} previous Previous semantic statement.
+     * @returns {boolean} Whether the exact authenticated support statement was consumed.
+     */
+    generatedLocalUse(node, previous) {
+        if (!this.runtime || previous?.kind != "LocalDeclaration" || node.type != "expression_statement")
+            return false;
+        const statementParts = this.parts(node);
+        const invocation = statementParts[0];
+        if (statementParts.length != 2 || invocation?.type != "method_invocation" || statementParts[1].text != ";")
+            return false;
+        const invocationParts = this.parts(invocation);
+        const functionNode = this.field(invocation, "function");
+        const argumentPart = this.field(invocation, "arguments");
+        if (invocationParts.length != 2 || invocationParts[0].id != functionNode.id || functionNode.type != "identifier" ||
+            functionNode.text != "_semantifoldUse" || invocationParts[1].id != argumentPart.id || argumentPart.type != "argument_part") {
+            return false;
+        }
+        this.shape(node, [invocation, ";"]);
+        this.shape(invocation, [functionNode, argumentPart]);
+        const arguments_ = this.arguments(argumentPart);
+        if (arguments_.length != 1 || arguments_[0].length != 1 || arguments_[0][0].type != "identifier" ||
+            this.identifier(arguments_[0][0]) != previous.name)
+            this.fail(argumentPart, "Dart analyzer local-use support shape");
+        return true;
+    }
+    /**
+     * Converts a braced Dart block.
+     * @param {import("tree-sitter").SyntaxNode} node Braced block.
+     * @returns {import("../semantic/types.js").Block} Semantic block.
+     */
+    block(node) {
+        const parts = this.parts(node);
+        if (node.type != "block" || parts.length < 2 || parts[0].text != "{" || parts.at(-1)?.text != "}") {
+            this.fail(node, "braced block shape");
+        }
+        this.shape(node, ["{", ...parts.slice(1, -1), "}"]);
+        /** @type {import("../semantic/types.js").Statement[]} */
+        const statements = [];
+        for (const statement of parts.slice(1, -1)) {
+            if (!this.generatedLocalUse(statement, statements.at(-1)))
+                statements.push(this.statement(statement));
+        }
+        return {
+            kind: /** @type {const} */ ("Block"),
+            location: this.location(node),
+            statements
+        };
+    }
+    /**
+     * Unwraps a synchronous braced function body.
+     * @param {import("tree-sitter").SyntaxNode} body Function body wrapper.
+     * @returns {import("../semantic/types.js").Block} Semantic body.
+     */
+    functionBody(body) {
+        const parts = this.parts(body);
+        if (body.type != "function_body" || parts.length != 1 || parts[0].type != "block") {
+            this.fail(body, "synchronous braced function body required");
+        }
+        this.shape(body, [parts[0]]);
+        return this.block(parts[0]);
+    }
+    /**
+     * Converts one strict-Boolean conditional.
+     * @param {import("tree-sitter").SyntaxNode} node Strict Boolean conditional.
+     * @returns {import("../semantic/types.js").IfStatement} Semantic conditional.
+     */
+    conditional(node) {
+        const parts = this.parts(node);
+        const consequence = this.field(node, "consequence");
+        const consequenceIndex = parts.findIndex(({ id }) => id == consequence.id);
+        if (node.type != "if_statement" || parts[0]?.text != "if" || parts[1]?.text != "(" || consequence.type != "block" ||
+            consequenceIndex < 4 || parts[consequenceIndex - 1]?.text != ")")
+            this.fail(node, "if statement shape");
+        const conditionParts = parts.slice(2, consequenceIndex - 1);
+        if (conditionParts.length == 0)
+            this.fail(node, "empty if condition");
+        const statement = /** @type {import("../semantic/types.js").IfStatement} */ ({
+            condition: this.expression(conditionParts, node),
+            consequent: this.block(consequence),
+            kind: /** @type {const} */ ("IfStatement"),
+            location: this.location(node)
+        });
+        if (parts.length == consequenceIndex + 1) {
+            this.shape(node, ["if", "(", ...conditionParts, ")", consequence]);
+            return statement;
+        }
+        const alternative = this.field(node, "alternative");
+        if (parts.length != consequenceIndex + 3 || parts[consequenceIndex + 1]?.text != "else" ||
+            parts[consequenceIndex + 2]?.id != alternative.id)
+            this.fail(alternative, "if alternate shape");
+        this.shape(node, ["if", "(", ...conditionParts, ")", consequence, "else", alternative]);
+        if (alternative.type == "block")
+            return { ...statement, alternate: this.block(alternative) };
+        if (alternative.type == "if_statement") {
+            return { ...statement, alternate: {
+                    kind: /** @type {const} */ ("Block"), location: this.location(alternative), statements: [this.conditional(alternative)]
+                } };
+        }
+        return this.fail(alternative, "braced block or else-if required");
+    }
+    /**
+     * Converts one required explicitly typed positional parameter.
+     * @param {import("tree-sitter").SyntaxNode} node Required positional parameter.
+     * @returns {import("../semantic/types.js").Parameter} Semantic parameter.
+     */
+    parameter(node) {
+        const parts = this.parts(node);
+        if (parts.length == 1 && parts[0].type == "identifier")
+            return missingType("dart", "Parameter", this.location(node));
+        if (node.type != "formal_parameter" || parts.length != 2 || parts[0].type != "type_identifier" ||
+            parts[1].type != "identifier")
+            this.fail(node, "required explicitly typed positional parameter");
+        this.shape(node, [parts[0], parts[1]]);
+        if (this.field(node, "name").id != parts[1].id)
+            this.fail(parts[1], "parameter name field");
+        const name = this.identifier(parts[1]);
+        return withParserRanges({
+            kind: /** @type {const} */ ("Parameter"), location: this.location(node), name, type: this.scalarType(parts[0])
+        }, { name: this.location(parts[1]) });
+    }
+    /**
+     * Converts a required positional parameter list.
+     * @param {import("tree-sitter").SyntaxNode} node Parameter list.
+     * @returns {import("../semantic/types.js").Parameter[]} Semantic parameters.
+     */
+    parameters(node) {
+        const parts = this.parts(node);
+        if (node.type != "formal_parameter_list" || parts.length < 2 || parts[0].text != "(" || parts.at(-1)?.text != ")") {
+            this.fail(node, "formal parameter list shape");
+        }
+        const interior = parts.slice(1, -1);
+        const hasGeneratedTrailingComma = this.runtime && interior.at(-1)?.text == ",";
+        const parameterParts = hasGeneratedTrailingComma ? interior.slice(0, -1) : interior;
+        const parameters = parameterParts.filter((_child, index) => index % 2 == 0);
+        this.shape(node, ["(", ...parameters.flatMap((parameter, index) => index ? [",", parameter] : [parameter]),
+            ...(hasGeneratedTrailingComma ? [","] : []), ")"]);
+        return parameters.map((parameter) => this.parameter(parameter));
+    }
+    /**
+     * Converts one ordinary top-level function declaration.
+     * @param {import("tree-sitter").SyntaxNode} signature Function signature.
+     * @param {import("tree-sitter").SyntaxNode} body Function body.
+     * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+     */
+    function(signature, body) {
+        const parts = this.parts(signature);
+        if (signature.type != "function_signature")
+            this.fail(signature, "function signature");
+        if (parts.length == 2 && parts[0].type == "identifier")
+            return missingType("dart", "Function return", this.location(signature));
+        if (parts.length != 3 || !["type_identifier", "void_type"].includes(parts[0].type) || parts[1].type != "identifier" ||
+            parts[2].type != "formal_parameter_list")
+            this.fail(signature, "explicit top-level function signature");
+        this.shape(signature, [parts[0], parts[1], parts[2]]);
+        if (this.field(signature, "name").id != parts[1].id)
+            this.fail(parts[1], "function name field");
+        const name = this.identifier(parts[1]);
+        const location = locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, signature.startIndex), bindingIndexToUtf16Offset(this.source, body.endIndex));
+        return withParserRanges({
+            body: this.functionBody(body),
+            kind: /** @type {const} */ ("FunctionDeclaration"),
+            location,
+            name,
+            parameters: this.parameters(parts[2]),
+            returnType: this.returnType(parts[0])
+        }, { name: this.location(parts[1]) });
+    }
+    /**
+     * Converts the exact void main entry shell.
+     * @param {import("tree-sitter").SyntaxNode} signature Main signature.
+     * @param {import("tree-sitter").SyntaxNode} body Main body.
+     * @returns {import("../semantic/types.js").EntryPoint} Semantic entry point.
+     */
+    main(signature, body) {
+        const parts = this.parts(signature);
+        if (signature.type != "function_signature" || parts.length != 3 || parts[0].type != "void_type" ||
+            this.identifier(parts[1], true) != "main" || parts[2].type != "formal_parameter_list") {
+            this.fail(signature, "exact void main() signature required");
+        }
+        this.shape(signature, [parts[0], parts[1], parts[2]]);
+        this.shape(parts[2], ["(", ")"]);
+        const location = locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, signature.startIndex), bindingIndexToUtf16Offset(this.source, body.endIndex));
+        return { body: this.functionBody(body), kind: /** @type {const} */ ("EntryPoint"), location };
+    }
+    /**
+     * Converts one complete Dart compilation unit.
+     * @param {import("tree-sitter").SyntaxNode} root Complete Dart program.
+     * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+     */
+    module(root) {
+        this.validateTree(root);
+        if (root.type != "program")
+            this.fail(root, "program root");
+        const parts = this.parts(root);
+        const supportTree = parser.parse(dartRuntime);
+        const support = this.parts(supportTree.rootNode);
+        let supportIndex = 0;
+        while (supportIndex < parts.length && supportIndex < support.length &&
+            parts[supportIndex].type == support[supportIndex].type) {
+            this.compareTree(parts[supportIndex], support[supportIndex]);
+            supportIndex += 1;
+        }
+        if (supportIndex > 0 && supportIndex != support.length) {
+            this.fail(parts[supportIndex - 1], "complete Dart support required");
+        }
+        this.runtime = supportIndex == support.length;
+        const semanticParts = parts.slice(supportIndex);
+        if (semanticParts.length == 0)
+            this.fail(root, "program without main");
+        /** @type {{body: import("tree-sitter").SyntaxNode, signature: import("tree-sitter").SyntaxNode}[]} */
+        const declarations = [];
+        for (const declaration of semanticParts) {
+            if (declaration.type != "function_declaration")
+                this.fail(declaration, "top-level function declaration required");
+            const signature = this.field(declaration, "signature");
+            const body = this.field(declaration, "body");
+            const declarationParts = this.parts(declaration);
+            if (declarationParts.length != 2 || declarationParts[0].id != signature.id || signature.type != "function_signature" ||
+                declarationParts[1].id != body.id || body.type != "function_body") {
+                this.fail(declaration, "paired top-level function signature and body required");
+            }
+            this.shape(declaration, [signature, body]);
+            declarations.push({ body, signature });
+        }
+        const mainIndexes = declarations.flatMap(({ signature }, index) => this.parts(signature)[1]?.text == "main" ? [index] : []);
+        if (mainIndexes.length != 1)
+            this.fail(root, "exactly one main declaration required");
+        const mainIndex = mainIndexes[0];
+        this.functionNames = new Set(declarations.map(({ signature }) => this.parts(signature)[1]?.text).filter(Boolean));
+        if (mainIndex != declarations.length - 1)
+            this.fail(declarations[mainIndex + 1].signature, "declaration after main");
+        const main = declarations[mainIndex];
+        const module = {
+            entryPoint: this.main(main.signature, main.body),
+            functions: declarations.slice(0, mainIndex).map(({ body, signature }) => this.function(signature, body)),
+            kind: /** @type {const} */ ("Module"),
+            location: this.location(root)
+        };
+        validateParsedModule(module, "dart");
+        return module;
+    }
+}
+/**
+ * Parses the strict Task 029 Dart VM/native profile through the qualified grammar.
+ * @param {{filename: string, source: string}} input Exact source request.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parseDart({ filename, source }) {
+    if (!hasOnlyUnicodeScalars(source)) {
+        const offset = firstLoneSurrogateOffset(source);
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR", language: "dart", location: locationFromOffsets(filename, source, offset, offset + 1),
+            message: "Dart source contains an invalid lone UTF-16 surrogate."
+        });
+    }
+    let tree;
+    try {
+        tree = parser.parse(source);
+    }
+    catch (error) {
+        throw new SemantifoldDiagnostic({
+            cause: error instanceof Error ? error : undefined,
+            code: "PARSE_ERROR",
+            language: "dart",
+            location: moduleLocation(filename, source),
+            message: "The qualified Dart parser could not produce a complete CST."
+        });
+    }
+    return new DartReader(filename, source).module(tree.rootNode);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dart.js","sourceRoot":"","sources":["../../../src/frontends/dart.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Parser from \"tree-sitter\"\nimport DartLanguage from \"tree-sitter-dart-orchard/bindings/node/index.js\"\nimport {isDartIdentifier} from \"../backends/identifiers.js\"\nimport {dartRuntime} from \"../backends/dart-runtime.js\"\nimport {missingType, SemantifoldDiagnostic, unsupportedSyntax} from \"../diagnostic.js\"\nimport {locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset} from \"../semantic/location.js\"\nimport {withAdaptedOperation} from \"../semantic/operators.js\"\nimport {withParserRanges} from \"../semantic/provenance.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {validateParsedModule} from \"../semantic/validate.js\"\nimport {sourceScalarType} from \"./scalars.js\"\n\nconst parser = new Parser()\n\nparser.setLanguage(/** @type {import(\"tree-sitter\").Language} */ (/** @type {unknown} */ (DartLanguage)))\n\nconst binaryOperations = new Map([\n  [\"+\", \"Add\"], [\"-\", \"Subtract\"], [\"*\", \"Multiply\"], [\"==\", \"Equal\"], [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"], [\"<=\", \"LessThanOrEqual\"], [\">\", \"GreaterThan\"], [\">=\", \"GreaterThanOrEqual\"],\n  [\"&&\", \"And\"], [\"||\", \"Or\"]\n])\n/** @type {Map<string, readonly [string, Set<string>]>} */\nconst binaryNodeOperators = new Map([\n  [\"additive_expression\", [\"additive_operator\", new Set([\"+\", \"-\"])]],\n  [\"multiplicative_expression\", [\"multiplicative_operator\", new Set([\"*\"])]],\n  [\"equality_expression\", [\"equality_operator\", new Set([\"==\", \"!=\"])]],\n  [\"relational_expression\", [\"relational_operator\", new Set([\"<\", \"<=\", \">\", \">=\"])]],\n  [\"logical_and_expression\", [\"logical_and_operator\", new Set([\"&&\"])]],\n  [\"logical_or_expression\", [\"logical_or_operator\", new Set([\"||\"])]]\n])\nconst commentTypes = new Set([\"comment\", \"documentation_comment\"])\n/** @type {Map<string, import(\"../semantic/operators.js\").AdaptedOperation>} */\nconst helperOperations = new Map([\n  [\"_semantifoldIntegerAdd\", \"Add\"], [\"_semantifoldIntegerSubtract\", \"Subtract\"],\n  [\"_semantifoldIntegerMultiply\", \"Multiply\"], [\"_semantifoldIntegerNegate\", \"Negate\"]\n])\n\n/**\n * Verifies a binding-reported UTF-16 index through the shared UTF-8 converter.\n * @param {string} source Complete source.\n * @param {number} index Binding 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 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  return -1\n}\n\n/** Consumes exact qualified Dart CST shapes without retaining parser values. */\nclass DartReader {\n  /**\n   * Creates a reader bound to one exact Dart source unit.\n   * @param {string} filename Original filename.\n   * @param {string} source Complete source.\n   */\n  constructor(filename, source) {\n    this.filename = filename\n    this.source = source\n    /** @type {Set<string>} */\n    this.functionNames = new Set()\n    this.runtime = false\n  }\n\n  /**\n   * Builds a semantic source location from one parser node.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Parser node.\n   * @returns {import(\"../semantic/types.js\").SourceLocation} Exact location.\n   */\n  location(node) {\n    return locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, node.startIndex),\n      bindingIndexToUtf16Offset(this.source, node.endIndex))\n  }\n\n  /**\n   * Rejects one parser node with a located unsupported-syntax diagnostic.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Violating node.\n   * @param {string} [detail] Profile detail.\n   * @returns {never} Always throws.\n   */\n  fail(node, detail = node.type) {\n    unsupportedSyntax(\"dart\", detail, this.location(node))\n  }\n\n  /**\n   * Traverses every named, anonymous, extra, field, and recovery edge.\n   * @param {import(\"tree-sitter\").SyntaxNode} root Complete parser root.\n   * @returns {void}\n   */\n  validateTree(root) {\n    const pending = [{depth: 0, node: root, visited: false}]\n\n    while (pending.length > 0) {\n      const current = pending.pop()\n\n      if (!current) throw new Error(\"Dart traversal lost a pending parser node.\")\n      const {depth, node, visited} = current\n\n      if (depth > 512) this.fail(node, \"CST exceeds the 512-level traversal limit\")\n      if (!visited) {\n        pending.push({depth, node, visited: true})\n        for (let index = node.childCount - 1; index >= 0; index -= 1) {\n          const child = node.child(index)\n\n          if (!child) throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`)\n          node.fieldNameForChild(index)\n          pending.push({depth: depth + 1, node: child, visited: false})\n        }\n        continue\n      }\n      if (node.hasError || node.isError || node.isMissing) {\n        throw new SemantifoldDiagnostic({\n          code: \"PARSE_ERROR\",\n          language: \"dart\",\n          location: this.location(node),\n          message: `Tree-sitter exposed recovery at '${node.type}'.`\n        })\n      }\n      if ([\"annotation\", \"import_or_export\", \"library_name\", \"part_header\", \"part_of_header\"].includes(node.type)) {\n        this.fail(node, node.type)\n      }\n      if (commentTypes.has(node.type) && (/(?:@dart\\s*=|dartfmt|ignore(?:_for_file)?\\s*:|language[-_ ]version)/iu.test(node.text) ||\n        /^\\/\\/ dart format (?:off|on)[\\t ]*$/u.test(node.text))) {\n        this.fail(node, \"directive-bearing comment\")\n      }\n    }\n  }\n\n  /**\n   * Omits only ordinary comments already covered by exhaustive traversal.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Parent node.\n   * @returns {import(\"tree-sitter\").SyntaxNode[]} Structural children.\n   */\n  parts(node) {\n    return node.children.filter((child) => !commentTypes.has(child.type))\n  }\n\n  /**\n   * Verifies an exact structural child sequence.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Shape owner.\n   * @param {(import(\"tree-sitter\").SyntaxNode | string)[]} expected Exact child sequence.\n   * @returns {void}\n   */\n  shape(node, expected) {\n    const actual = this.parts(node)\n\n    if (actual.length != expected.length) this.fail(actual[Math.min(actual.length, expected.length)] ?? node, `${node.type} child shape`)\n    for (let index = 0; index < expected.length; index += 1) {\n      const wanted = expected[index]\n      const child = actual[index]\n      const matches = typeof wanted == \"string\" ? child.text == wanted : child.id == wanted.id\n\n      if (!matches) this.fail(child, `${node.type} child shape`)\n    }\n  }\n\n  /**\n   * Consumes an Orchard operator wrapper whether its token is aliased into the wrapper or exposed anonymously.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Operator node.\n   * @returns {void}\n   */\n  operatorShape(node) {\n    const parts = this.parts(node)\n\n    if (parts.length > 1 || parts.length == 1 && (parts[0].isNamed || parts[0].text != node.text)) {\n      this.fail(node, `${node.type} child shape`)\n    }\n    this.shape(node, parts.length == 0 ? [] : [node.text])\n  }\n\n  /**\n   * Returns exactly one parser child carrying a requested field name.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Field owner.\n   * @param {string} name Field name.\n   * @returns {import(\"tree-sitter\").SyntaxNode} Sole field node.\n   */\n  field(node, name) {\n    const matches = []\n\n    for (let index = 0; index < node.childCount; index += 1) {\n      const child = node.child(index)\n\n      if (!child) throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`)\n      if (node.fieldNameForChild(index) == name) matches.push(child)\n    }\n    if (matches.length != 1) this.fail(node, `expected one '${name}' field`)\n    return matches[0]\n  }\n\n  /**\n   * Validates and returns a source identifier.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Identifier token.\n   * @param {boolean} [allowMain] Whether fixed main is expected.\n   * @param {boolean} [allowPrint] Whether fixed print is expected.\n   * @returns {string} Accepted name.\n   */\n  identifier(node, allowMain = false, allowPrint = false) {\n    const name = node.text\n\n    if (node.type != \"identifier\" || !(allowMain && name == \"main\") && !(allowPrint && name == \"print\") &&\n      !isDartIdentifier(name)) this.fail(node, \"reserved or unsupported identifier\")\n    return name\n  }\n\n  /**\n   * Converts one explicitly named scalar type.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Type node.\n   * @returns {import(\"../semantic/types.js\").TypeReference} Scalar type.\n   */\n  scalarType(node) {\n    if (node.type != \"type_identifier\" || this.parts(node).length != 0) this.fail(node, \"scalar type shape\")\n    const type = sourceScalarType(\"dart\", node.text, this.location(node))\n\n    if (!type) this.fail(node, `unsupported scalar type '${node.text}'`)\n    return type\n  }\n\n  /**\n   * Converts one explicit scalar or void result type.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Return type node.\n   * @returns {import(\"../semantic/types.js\").SemanticFunctionReturnType} Function return type.\n   */\n  returnType(node) {\n    if (node.type == \"void_type\") {\n      const parts = this.parts(node)\n\n      if (node.text != \"void\" || parts.length > 1 || parts.length == 1 && parts[0].text != \"void\") {\n        this.fail(node, \"void type shape\")\n      }\n      this.shape(node, parts)\n      const type = {kind: /** @type {const} */ (\"TypeReference\"), name: /** @type {const} */ (\"void\")}\n\n      return withParserRanges(type, {type: this.location(node)})\n    }\n    return this.scalarType(node)\n  }\n\n  /**\n   * Decodes one ordinary noninterpolated, non-raw, single-line Dart string.\n   * @param {import(\"tree-sitter\").SyntaxNode} node String node.\n   * @returns {string} Decoded Unicode scalar value.\n   */\n  string(node) {\n    const parts = this.parts(node)\n    const delimiter = node.text[0]\n\n    if (node.type != \"string_literal\" || ![\"\\\"\", \"'\"].includes(delimiter) || node.text.startsWith(delimiter.repeat(3)) ||\n      node.text.at(-1) != delimiter || parts.length < 2 || parts[0].text != delimiter || parts.at(-1)?.text != delimiter ||\n      parts.slice(1, -1).some(({type}) => type != \"escape_sequence\")) {\n      this.fail(node, \"ordinary noninterpolated string literal required\")\n    }\n    this.shape(node, parts)\n    const source = node.text.slice(1, -1)\n    const simpleEscapes = new Map([\n      [\"b\", \"\\b\"], [\"f\", \"\\f\"], [\"n\", \"\\n\"], [\"r\", \"\\r\"], [\"t\", \"\\t\"], [\"v\", \"\\v\"],\n      [\"$\", \"$\"], [\"'\", \"'\"], ['\"', '\"'], [\"\\\\\", \"\\\\\"]\n    ])\n    let value = \"\"\n\n    for (let index = 0; index < source.length; index += 1) {\n      const character = source[index]\n\n      if (character != \"\\\\\") {\n        if (character == \"\\n\" || character == \"\\r\" || character == delimiter || character == \"$\") {\n          this.fail(node, \"invalid or interpolated string content\")\n        }\n        value += character\n        continue\n      }\n      const escaped = source[++index]\n\n      if (simpleEscapes.has(escaped)) value += simpleEscapes.get(escaped)\n      else if (escaped == \"x\") {\n        const hexadecimal = source.slice(index + 1, index + 3)\n\n        if (!/^[0-9A-Fa-f]{2}$/u.test(hexadecimal)) this.fail(node, \"unsupported string escape\")\n        value += String.fromCodePoint(Number.parseInt(hexadecimal, 16))\n        index += 2\n      } else if (escaped == \"u\") {\n        if (source[index + 1] == \"{\") {\n          const closing = source.indexOf(\"}\", index + 2)\n          const hexadecimal = closing < 0 ? \"\" : source.slice(index + 2, closing)\n          const codePoint = /^[0-9A-Fa-f]{1,6}$/u.test(hexadecimal) ? Number.parseInt(hexadecimal, 16) : -1\n\n          if (codePoint < 0 || codePoint > 0x10FFFF) this.fail(node, \"unsupported string escape\")\n          value += String.fromCodePoint(codePoint)\n          index = closing\n        } else {\n          const hexadecimal = source.slice(index + 1, index + 5)\n\n          if (!/^[0-9A-Fa-f]{4}$/u.test(hexadecimal)) this.fail(node, \"unsupported string escape\")\n          value += String.fromCharCode(Number.parseInt(hexadecimal, 16))\n          index += 4\n        }\n      } else this.fail(node, \"unsupported string escape\")\n    }\n    if (!hasOnlyUnicodeScalars(value)) this.fail(node, \"invalid Unicode string literal\")\n    return value\n  }\n\n  /**\n   * Extracts exact required positional arguments.\n   * @param {import(\"tree-sitter\").SyntaxNode} part Call argument part.\n   * @returns {import(\"tree-sitter\").SyntaxNode[][]} Argument expression edges.\n   */\n  arguments(part) {\n    const partChildren = this.parts(part)\n\n    if (part.type != \"argument_part\" || partChildren.length != 1 || partChildren[0].type != \"arguments\") {\n      this.fail(part, \"call argument part shape\")\n    }\n    this.shape(part, [partChildren[0]])\n    const list = partChildren[0]\n    const listParts = this.parts(list)\n\n    if (listParts.length < 2 || listParts[0].text != \"(\" || listParts.at(-1)?.text != \")\") {\n      this.fail(list, \"call argument list shape\")\n    }\n    const interior = listParts.slice(1, -1)\n    const hasGeneratedTrailingComma = this.runtime && interior.at(-1)?.text == \",\"\n    const argumentParts = hasGeneratedTrailingComma ? interior.slice(0, -1) : interior\n    const arguments_ = argumentParts.filter((_child, index) => index % 2 == 0)\n\n    this.shape(list, [\"(\", ...arguments_.flatMap((argument, index) => index ? [\",\", argument] : [argument]),\n      ...(hasGeneratedTrailingComma ? [\",\"] : []), \")\"])\n    return arguments_.map((argument) => {\n      if (argument.type != \"argument\") this.fail(argument, \"required positional argument\")\n      const expressionParts = this.parts(argument)\n\n      if (expressionParts.length == 0) this.fail(argument, \"empty argument\")\n      return expressionParts\n    })\n  }\n\n  /**\n   * Converts one direct method-invocation node whose function is a plain identifier.\n   * @param {import(\"tree-sitter\").SyntaxNode[]} nodes Exact one-node call.\n   * @param {import(\"tree-sitter\").SyntaxNode} owner Expression owner.\n   * @param {boolean} [allowPrint] Whether this is the print scaffold.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic call or private generated operation.\n   */\n  call(nodes, owner, allowPrint = false) {\n    if (nodes.length != 1 || nodes[0].type != \"method_invocation\") {\n      this.fail(nodes[0] ?? owner, \"direct call shape\")\n    }\n    const invocation = nodes[0]\n    const parts = this.parts(invocation)\n    const functionNode = this.field(invocation, \"function\")\n    const argumentPart = this.field(invocation, \"arguments\")\n\n    if (parts.length != 2 || parts[0].id != functionNode.id || functionNode.type != \"identifier\" ||\n      parts[1].id != argumentPart.id || argumentPart.type != \"argument_part\") this.fail(invocation, \"direct call shape\")\n    this.shape(invocation, [functionNode, argumentPart])\n    const name = functionNode.text\n    const helper = this.runtime ? helperOperations.get(name) : undefined\n    const location = this.location(invocation)\n    const argumentNodes = this.arguments(argumentPart)\n\n    if (this.runtime && name == \"_semantifoldBoolean\") {\n      if (argumentNodes.length != 1) this.fail(argumentPart, \"Dart Boolean literal helper shape\")\n      const literal = this.expression(argumentNodes[0], owner)\n\n      if (literal.kind != \"BooleanLiteral\") this.fail(argumentPart, \"Dart Boolean literal helper shape\")\n      return literal\n    }\n    if (helper) {\n      const count = helper == \"Negate\" ? 1 : 2\n\n      if (argumentNodes.length != count) this.fail(argumentPart, \"Dart checked-integer helper shape\")\n      if (helper == \"Negate\") {\n        return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (\n          withAdaptedOperation(withParserRanges({\n            kind: /** @type {const} */ (\"UnaryExpression\"), location,\n            operand: this.expression(argumentNodes[0], owner)\n          }, {operator: this.location(functionNode)}), helper)))\n      }\n      return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (\n        withAdaptedOperation(withParserRanges({\n          kind: /** @type {const} */ (\"BinaryExpression\"), left: this.expression(argumentNodes[0], owner), location,\n          right: this.expression(argumentNodes[1], owner)\n        }, {operator: this.location(functionNode)}), helper)))\n    }\n    this.identifier(functionNode, false, allowPrint)\n\n    return withParserRanges({\n      arguments: argumentNodes.map((argument) => this.expression(argument, owner)),\n      callee: name,\n      kind: /** @type {const} */ (\"CallExpression\"),\n      location\n    }, {callee: this.location(functionNode)})\n  }\n\n  /**\n   * Recursively compares one source support subtree with the canonical runtime CST.\n   * @param {import(\"tree-sitter\").SyntaxNode} actual Source node.\n   * @param {import(\"tree-sitter\").SyntaxNode} expected Canonical node.\n   * @returns {void}\n   */\n  compareTree(actual, expected) {\n    if (actual.type != expected.type || actual.isNamed != expected.isNamed || actual.isExtra != expected.isExtra ||\n      actual.childCount != expected.childCount) this.fail(actual, \"modified Dart support node\")\n    if (actual.childCount == 0 && actual.text != expected.text) this.fail(actual, \"modified Dart support token\")\n    for (let index = 0; index < actual.childCount; index += 1) {\n      const left = actual.child(index)\n      const right = expected.child(index)\n\n      if (!left || !right || actual.fieldNameForChild(index) != expected.fieldNameForChild(index)) {\n        this.fail(left ?? actual, \"modified Dart support field\")\n      }\n      this.compareTree(left, right)\n    }\n  }\n\n  /**\n   * Converts an expression represented by one or more adjacent Dart CST nodes.\n   * @param {import(\"tree-sitter\").SyntaxNode[]} nodes Expression nodes.\n   * @param {import(\"tree-sitter\").SyntaxNode} owner Owning node.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n   */\n  expression(nodes, owner) {\n    if (nodes.length == 1 && nodes[0].type == \"method_invocation\") return this.call(nodes, owner)\n    if (nodes.length != 1) return this.fail(nodes[0] ?? owner, \"scalar expression shape\")\n    const node = nodes[0]\n    const location = this.location(node)\n\n    if (node.type == \"identifier\") {\n      const name = this.identifier(node)\n\n      if (this.functionNames.has(name)) this.fail(node, \"function tear-off\")\n      return withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location, name}, {name: location})\n    }\n    if (node.type == \"decimal_integer_literal\") {\n      if (this.parts(node).length != 0 || !/^(?:0|[1-9][0-9]*)$/u.test(node.text)) this.fail(node, \"noncanonical integer literal\")\n      const value = Number(BigInt(node.text))\n\n      if (!Number.isSafeInteger(value)) this.fail(node, \"non-safe integer literal\")\n      return withParserRanges({kind: /** @type {const} */ (\"IntegerLiteral\"), location, value}, {literal: location})\n    }\n    if (node.type == \"true\" || node.type == \"false\") {\n      this.shape(node, [node.type])\n      return withParserRanges({kind: /** @type {const} */ (\"BooleanLiteral\"), location, value: node.type == \"true\"}, {literal: location})\n    }\n    if (node.type == \"string_literal\") {\n      return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: this.string(node)}, {literal: location})\n    }\n    if (node.type == \"parenthesized_expression\") {\n      const parts = this.parts(node)\n\n      if (parts.length < 3 || parts[0].text != \"(\" || parts.at(-1)?.text != \")\") this.fail(node, \"parenthesized expression shape\")\n      this.shape(node, [\"(\", ...parts.slice(1, -1), \")\"])\n      return this.expression(parts.slice(1, -1), node)\n    }\n    if (node.type == \"unary_expression\") {\n      const parts = this.parts(node)\n      const operator = parts[0]\n\n      if (parts.length < 2 || operator.type != \"prefix_operator\" || ![\"-\", \"!\"].includes(operator.text)) {\n        this.fail(node, \"unary operator\")\n      }\n      const operatorParts = this.parts(operator)\n\n      if (operatorParts.length != 1 || operatorParts[0].text != operator.text ||\n        ![\"minus_operator\", \"negation_operator\"].includes(operatorParts[0].type)) this.fail(operator, \"unary operator shape\")\n      this.operatorShape(operatorParts[0])\n      this.shape(node, [operator, ...parts.slice(1)])\n      return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n        kind: /** @type {const} */ (\"UnaryExpression\"),\n        location,\n        operand: this.expression(parts.slice(1), node)\n      }, {operator: this.location(operator)}), operator.text == \"-\" ? \"Negate\" : \"Not\")))\n    }\n    if (binaryNodeOperators.has(node.type)) return this.binary(node)\n    return this.fail(node)\n  }\n\n  /**\n   * Converts a bounded binary expression tree.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Binary expression node.\n   * @returns {import(\"../semantic/types.js\").Expression} Semantic binary expression.\n   */\n  binary(node) {\n    /** @type {import(\"tree-sitter\").SyntaxNode[][]} */\n    const operands = []\n    /** @type {import(\"tree-sitter\").SyntaxNode[]} */\n    const operators = []\n    let current = node\n\n    while (true) {\n      const parts = this.parts(current)\n      const declaration = binaryNodeOperators.get(current.type)\n      const operatorType = declaration?.[0]\n      const accepted = declaration?.[1]\n      const operatorIndexes = parts.flatMap((part, index) => part.type == operatorType ? [index] : [])\n\n      if (operatorIndexes.length != 1) this.fail(current, `${current.type} child shape`)\n      const operatorIndex = operatorIndexes[0]\n      const operator = parts[operatorIndex]\n\n      if (operatorIndex == 0 || operatorIndex == parts.length - 1 || !accepted?.has(operator.text) ||\n        !binaryOperations.has(operator.text)) this.fail(operator, \"unsupported binary operator\")\n      this.operatorShape(operator)\n      this.shape(current, parts)\n      operands.push(parts.slice(0, operatorIndex))\n      operators.push(operator)\n      const right = parts.slice(operatorIndex + 1)\n\n      if (right.length == 1 && right[0].type == node.type) current = right[0]\n      else {\n        operands.push(right)\n        break\n      }\n    }\n    let expression = this.expression(operands[0], node)\n\n    for (let index = 0; index < operators.length; index += 1) {\n      const operator = operators[index]\n      const operation = binaryOperations.get(operator.text)\n      const right = this.expression(operands[index + 1], node)\n      const first = operands[0][0]\n      const last = operands[index + 1].at(-1)\n      const location = first && last\n        ? locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, first.startIndex),\n          bindingIndexToUtf16Offset(this.source, last.endIndex))\n        : this.location(node)\n\n      expression = /** @type {import(\"../semantic/types.js\").Expression} */ (withAdaptedOperation(withParserRanges({\n        kind: /** @type {const} */ (\"BinaryExpression\"), left: expression, location, right\n      }, {operator: this.location(operator)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (operation)))\n    }\n    return expression\n  }\n\n  /**\n   * Converts one explicitly typed initialized local declaration.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Local declaration.\n   * @returns {import(\"../semantic/types.js\").LocalDeclaration} Semantic local.\n   */\n  local(node) {\n    const declarationParts = this.parts(node)\n\n    if (node.type != \"local_variable_declaration\" || declarationParts.length != 2 ||\n      declarationParts[0].type != \"initialized_variable_definition\" || declarationParts[1].text != \";\") {\n      this.fail(node, \"local declaration shape\")\n    }\n    this.shape(node, [declarationParts[0], \";\"])\n    const definition = declarationParts[0]\n    const parts = this.parts(definition)\n\n    if (parts[0]?.type == \"inferred_type\" || parts[0]?.type == \"final_builtin\" && parts[1]?.type == \"identifier\") {\n      return missingType(\"dart\", \"Local\", this.location(definition))\n    }\n    const immutable = parts[0]?.type == \"final_builtin\"\n    const typeIndex = immutable ? 1 : 0\n    const typeNode = parts[typeIndex]\n    const nameNode = parts[typeIndex + 1]\n    const equals = parts[typeIndex + 2]\n    const expressionParts = parts.slice(typeIndex + 3)\n\n    if (parts.length < typeIndex + 4 || typeNode?.type != \"type_identifier\" || nameNode?.type != \"identifier\" ||\n      equals?.text != \"=\" || expressionParts.length == 0 || immutable && parts[0].text != \"final\") {\n      this.fail(parts[0] ?? definition, \"explicitly typed initialized local required\")\n    }\n    this.shape(definition, [...(immutable ? [parts[0]] : []), typeNode, nameNode, \"=\", ...expressionParts])\n    if (this.field(definition, \"name\").id != nameNode.id) this.fail(nameNode, \"local name field\")\n    const name = this.identifier(nameNode)\n\n    return withParserRanges({\n      initializer: this.expression(expressionParts, definition),\n      kind: /** @type {const} */ (\"LocalDeclaration\"),\n      location: this.location(node),\n      mutable: !immutable,\n      name,\n      type: this.scalarType(typeNode)\n    }, {name: this.location(nameNode), operator: this.location(equals)})\n  }\n\n  /**\n   * Converts one simple identifier assignment.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Assignment expression.\n   * @returns {import(\"../semantic/types.js\").AssignmentStatement} Semantic assignment.\n   */\n  assignment(node) {\n    const parts = this.parts(node)\n    const target = parts[0]\n    const operator = parts[1]\n\n    if (node.type != \"assignment_expression\" || parts.length < 3 || target?.type != \"assignable_expression\" ||\n      operator?.type != \"assignment_operator\" || operator.text != \"=\") this.fail(node, \"simple assignment shape\")\n    const targetParts = this.parts(target)\n\n    if (targetParts.length != 1 || targetParts[0].type != \"identifier\") this.fail(target, \"simple assignment target\")\n    this.shape(target, [targetParts[0]])\n    this.operatorShape(operator)\n    this.shape(node, [target, \"=\", ...parts.slice(2)])\n    const name = this.identifier(targetParts[0])\n    const targetLocation = this.location(targetParts[0])\n\n    return withParserRanges({\n      expression: this.expression(parts.slice(2), node),\n      kind: /** @type {const} */ (\"AssignmentStatement\"),\n      location: this.location(node),\n      target: withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: targetLocation, name}, {name: targetLocation})\n    }, {operator: this.location(operator)})\n  }\n\n  /**\n   * Converts one supported Dart statement.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Source statement.\n   * @returns {import(\"../semantic/types.js\").Statement} Semantic statement.\n   */\n  statement(node) {\n    if (node.type == \"local_variable_declaration\") return this.local(node)\n    if (node.type == \"if_statement\") return this.conditional(node)\n    if (node.type == \"return_statement\") {\n      const parts = this.parts(node)\n\n      if (parts.length < 2 || parts[0].text != \"return\" || parts.at(-1)?.text != \";\") this.fail(node, \"return statement shape\")\n      this.shape(node, [\"return\", ...parts.slice(1, -1), \";\"])\n      const expressionParts = parts.slice(1, -1)\n\n      return {\n        ...(expressionParts.length > 0 ? {expression: this.expression(expressionParts, node)} : {}),\n        kind: /** @type {const} */ (\"ReturnStatement\"),\n        location: this.location(node)\n      }\n    }\n    if (node.type == \"expression_statement\") {\n      const parts = this.parts(node)\n\n      if (parts.length < 2 || parts.at(-1)?.text != \";\") this.fail(node, \"expression statement shape\")\n      this.shape(node, [...parts.slice(0, -1), \";\"])\n      if (parts.length == 2 && parts[0].type == \"assignment_expression\") return this.assignment(parts[0])\n      const callParts = parts.slice(0, -1)\n      const callChildren = callParts.length == 1 && callParts[0].type == \"method_invocation\"\n        ? this.parts(callParts[0]) : []\n      const print = callChildren[0]?.type == \"identifier\" && callChildren[0].text == \"print\"\n      const expression = this.call(callParts, node, print)\n\n      if (print) {\n        if (expression.kind != \"CallExpression\" || expression.arguments.length != 1) {\n          this.fail(callParts[0], \"print argument count\")\n        }\n        return {expression: expression.arguments[0], kind: /** @type {const} */ (\"PrintStatement\"), location: this.location(node)}\n      }\n      if (expression.kind != \"CallExpression\") this.fail(callParts[0], \"generated helper expression statement\")\n      return {expression, kind: /** @type {const} */ (\"ExpressionStatement\"), location: this.location(node)}\n    }\n    return this.fail(node)\n  }\n\n  /**\n   * Consumes one compiler-owned read that prevents Dart from rejecting an otherwise unread local.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Candidate source statement.\n   * @param {import(\"../semantic/types.js\").Statement | undefined} previous Previous semantic statement.\n   * @returns {boolean} Whether the exact authenticated support statement was consumed.\n   */\n  generatedLocalUse(node, previous) {\n    if (!this.runtime || previous?.kind != \"LocalDeclaration\" || node.type != \"expression_statement\") return false\n    const statementParts = this.parts(node)\n    const invocation = statementParts[0]\n\n    if (statementParts.length != 2 || invocation?.type != \"method_invocation\" || statementParts[1].text != \";\") return false\n    const invocationParts = this.parts(invocation)\n    const functionNode = this.field(invocation, \"function\")\n    const argumentPart = this.field(invocation, \"arguments\")\n\n    if (invocationParts.length != 2 || invocationParts[0].id != functionNode.id || functionNode.type != \"identifier\" ||\n      functionNode.text != \"_semantifoldUse\" || invocationParts[1].id != argumentPart.id || argumentPart.type != \"argument_part\") {\n      return false\n    }\n    this.shape(node, [invocation, \";\"])\n    this.shape(invocation, [functionNode, argumentPart])\n    const arguments_ = this.arguments(argumentPart)\n\n    if (arguments_.length != 1 || arguments_[0].length != 1 || arguments_[0][0].type != \"identifier\" ||\n      this.identifier(arguments_[0][0]) != previous.name) this.fail(argumentPart, \"Dart analyzer local-use support shape\")\n    return true\n  }\n\n  /**\n   * Converts a braced Dart block.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Braced block.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n   */\n  block(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"block\" || parts.length < 2 || parts[0].text != \"{\" || parts.at(-1)?.text != \"}\") {\n      this.fail(node, \"braced block shape\")\n    }\n    this.shape(node, [\"{\", ...parts.slice(1, -1), \"}\"])\n    /** @type {import(\"../semantic/types.js\").Statement[]} */\n    const statements = []\n\n    for (const statement of parts.slice(1, -1)) {\n      if (!this.generatedLocalUse(statement, statements.at(-1))) statements.push(this.statement(statement))\n    }\n    return {\n      kind: /** @type {const} */ (\"Block\"),\n      location: this.location(node),\n      statements\n    }\n  }\n\n  /**\n   * Unwraps a synchronous braced function body.\n   * @param {import(\"tree-sitter\").SyntaxNode} body Function body wrapper.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic body.\n   */\n  functionBody(body) {\n    const parts = this.parts(body)\n\n    if (body.type != \"function_body\" || parts.length != 1 || parts[0].type != \"block\") {\n      this.fail(body, \"synchronous braced function body required\")\n    }\n    this.shape(body, [parts[0]])\n    return this.block(parts[0])\n  }\n\n  /**\n   * Converts one strict-Boolean conditional.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Strict Boolean conditional.\n   * @returns {import(\"../semantic/types.js\").IfStatement} Semantic conditional.\n   */\n  conditional(node) {\n    const parts = this.parts(node)\n    const consequence = this.field(node, \"consequence\")\n    const consequenceIndex = parts.findIndex(({id}) => id == consequence.id)\n\n    if (node.type != \"if_statement\" || parts[0]?.text != \"if\" || parts[1]?.text != \"(\" || consequence.type != \"block\" ||\n      consequenceIndex < 4 || parts[consequenceIndex - 1]?.text != \")\") this.fail(node, \"if statement shape\")\n    const conditionParts = parts.slice(2, consequenceIndex - 1)\n\n    if (conditionParts.length == 0) this.fail(node, \"empty if condition\")\n    const statement = /** @type {import(\"../semantic/types.js\").IfStatement} */ ({\n      condition: this.expression(conditionParts, node),\n      consequent: this.block(consequence),\n      kind: /** @type {const} */ (\"IfStatement\"),\n      location: this.location(node)\n    })\n    if (parts.length == consequenceIndex + 1) {\n      this.shape(node, [\"if\", \"(\", ...conditionParts, \")\", consequence])\n      return statement\n    }\n    const alternative = this.field(node, \"alternative\")\n\n    if (parts.length != consequenceIndex + 3 || parts[consequenceIndex + 1]?.text != \"else\" ||\n      parts[consequenceIndex + 2]?.id != alternative.id) this.fail(alternative, \"if alternate shape\")\n    this.shape(node, [\"if\", \"(\", ...conditionParts, \")\", consequence, \"else\", alternative])\n    if (alternative.type == \"block\") return {...statement, alternate: this.block(alternative)}\n    if (alternative.type == \"if_statement\") {\n      return {...statement, alternate: {\n        kind: /** @type {const} */ (\"Block\"), location: this.location(alternative), statements: [this.conditional(alternative)]\n      }}\n    }\n    return this.fail(alternative, \"braced block or else-if required\")\n  }\n\n  /**\n   * Converts one required explicitly typed positional parameter.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Required positional parameter.\n   * @returns {import(\"../semantic/types.js\").Parameter} Semantic parameter.\n   */\n  parameter(node) {\n    const parts = this.parts(node)\n\n    if (parts.length == 1 && parts[0].type == \"identifier\") return missingType(\"dart\", \"Parameter\", this.location(node))\n    if (node.type != \"formal_parameter\" || parts.length != 2 || parts[0].type != \"type_identifier\" ||\n      parts[1].type != \"identifier\") this.fail(node, \"required explicitly typed positional parameter\")\n    this.shape(node, [parts[0], parts[1]])\n    if (this.field(node, \"name\").id != parts[1].id) this.fail(parts[1], \"parameter name field\")\n    const name = this.identifier(parts[1])\n\n    return withParserRanges({\n      kind: /** @type {const} */ (\"Parameter\"), location: this.location(node), name, type: this.scalarType(parts[0])\n    }, {name: this.location(parts[1])})\n  }\n\n  /**\n   * Converts a required positional parameter list.\n   * @param {import(\"tree-sitter\").SyntaxNode} node Parameter list.\n   * @returns {import(\"../semantic/types.js\").Parameter[]} Semantic parameters.\n   */\n  parameters(node) {\n    const parts = this.parts(node)\n\n    if (node.type != \"formal_parameter_list\" || parts.length < 2 || parts[0].text != \"(\" || parts.at(-1)?.text != \")\") {\n      this.fail(node, \"formal parameter list shape\")\n    }\n    const interior = parts.slice(1, -1)\n    const hasGeneratedTrailingComma = this.runtime && interior.at(-1)?.text == \",\"\n    const parameterParts = hasGeneratedTrailingComma ? interior.slice(0, -1) : interior\n    const parameters = parameterParts.filter((_child, index) => index % 2 == 0)\n\n    this.shape(node, [\"(\", ...parameters.flatMap((parameter, index) => index ? [\",\", parameter] : [parameter]),\n      ...(hasGeneratedTrailingComma ? [\",\"] : []), \")\"])\n    return parameters.map((parameter) => this.parameter(parameter))\n  }\n\n  /**\n   * Converts one ordinary top-level function declaration.\n   * @param {import(\"tree-sitter\").SyntaxNode} signature Function signature.\n   * @param {import(\"tree-sitter\").SyntaxNode} body Function body.\n   * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n   */\n  function(signature, body) {\n    const parts = this.parts(signature)\n\n    if (signature.type != \"function_signature\") this.fail(signature, \"function signature\")\n    if (parts.length == 2 && parts[0].type == \"identifier\") return missingType(\"dart\", \"Function return\", this.location(signature))\n    if (parts.length != 3 || ![\"type_identifier\", \"void_type\"].includes(parts[0].type) || parts[1].type != \"identifier\" ||\n      parts[2].type != \"formal_parameter_list\") this.fail(signature, \"explicit top-level function signature\")\n    this.shape(signature, [parts[0], parts[1], parts[2]])\n    if (this.field(signature, \"name\").id != parts[1].id) this.fail(parts[1], \"function name field\")\n    const name = this.identifier(parts[1])\n    const location = locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, signature.startIndex),\n      bindingIndexToUtf16Offset(this.source, body.endIndex))\n\n    return withParserRanges({\n      body: this.functionBody(body),\n      kind: /** @type {const} */ (\"FunctionDeclaration\"),\n      location,\n      name,\n      parameters: this.parameters(parts[2]),\n      returnType: this.returnType(parts[0])\n    }, {name: this.location(parts[1])})\n  }\n\n  /**\n   * Converts the exact void main entry shell.\n   * @param {import(\"tree-sitter\").SyntaxNode} signature Main signature.\n   * @param {import(\"tree-sitter\").SyntaxNode} body Main body.\n   * @returns {import(\"../semantic/types.js\").EntryPoint} Semantic entry point.\n   */\n  main(signature, body) {\n    const parts = this.parts(signature)\n\n    if (signature.type != \"function_signature\" || parts.length != 3 || parts[0].type != \"void_type\" ||\n      this.identifier(parts[1], true) != \"main\" || parts[2].type != \"formal_parameter_list\") {\n      this.fail(signature, \"exact void main() signature required\")\n    }\n    this.shape(signature, [parts[0], parts[1], parts[2]])\n    this.shape(parts[2], [\"(\", \")\"])\n    const location = locationFromOffsets(this.filename, this.source, bindingIndexToUtf16Offset(this.source, signature.startIndex),\n      bindingIndexToUtf16Offset(this.source, body.endIndex))\n\n    return {body: this.functionBody(body), kind: /** @type {const} */ (\"EntryPoint\"), location}\n  }\n\n  /**\n   * Converts one complete Dart compilation unit.\n   * @param {import(\"tree-sitter\").SyntaxNode} root Complete Dart program.\n   * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n   */\n  module(root) {\n    this.validateTree(root)\n    if (root.type != \"program\") this.fail(root, \"program root\")\n    const parts = this.parts(root)\n    const supportTree = parser.parse(dartRuntime)\n    const support = this.parts(supportTree.rootNode)\n    let supportIndex = 0\n\n    while (supportIndex < parts.length && supportIndex < support.length &&\n      parts[supportIndex].type == support[supportIndex].type) {\n      this.compareTree(parts[supportIndex], support[supportIndex])\n      supportIndex += 1\n    }\n    if (supportIndex > 0 && supportIndex != support.length) {\n      this.fail(parts[supportIndex - 1], \"complete Dart support required\")\n    }\n    this.runtime = supportIndex == support.length\n    const semanticParts = parts.slice(supportIndex)\n\n    if (semanticParts.length == 0) this.fail(root, \"program without main\")\n    /** @type {{body: import(\"tree-sitter\").SyntaxNode, signature: import(\"tree-sitter\").SyntaxNode}[]} */\n    const declarations = []\n\n    for (const declaration of semanticParts) {\n      if (declaration.type != \"function_declaration\") this.fail(declaration, \"top-level function declaration required\")\n      const signature = this.field(declaration, \"signature\")\n      const body = this.field(declaration, \"body\")\n      const declarationParts = this.parts(declaration)\n\n      if (declarationParts.length != 2 || declarationParts[0].id != signature.id || signature.type != \"function_signature\" ||\n        declarationParts[1].id != body.id || body.type != \"function_body\") {\n        this.fail(declaration, \"paired top-level function signature and body required\")\n      }\n      this.shape(declaration, [signature, body])\n      declarations.push({body, signature})\n    }\n    const mainIndexes = declarations.flatMap(({signature}, index) => this.parts(signature)[1]?.text == \"main\" ? [index] : [])\n\n    if (mainIndexes.length != 1) this.fail(root, \"exactly one main declaration required\")\n    const mainIndex = mainIndexes[0]\n\n    this.functionNames = new Set(declarations.map(({signature}) => this.parts(signature)[1]?.text).filter(Boolean))\n\n    if (mainIndex != declarations.length - 1) this.fail(declarations[mainIndex + 1].signature, \"declaration after main\")\n    const main = declarations[mainIndex]\n    const module = {\n      entryPoint: this.main(main.signature, main.body),\n      functions: declarations.slice(0, mainIndex).map(({body, signature}) => this.function(signature, body)),\n      kind: /** @type {const} */ (\"Module\"),\n      location: this.location(root)\n    }\n\n    validateParsedModule(module, \"dart\")\n    return module\n  }\n}\n\n/**\n * Parses the strict Task 029 Dart VM/native profile through the qualified grammar.\n * @param {{filename: string, source: string}} input Exact source request.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parseDart({filename, source}) {\n  if (!hasOnlyUnicodeScalars(source)) {\n    const offset = firstLoneSurrogateOffset(source)\n\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\", language: \"dart\", location: locationFromOffsets(filename, source, offset, offset + 1),\n      message: \"Dart source contains an invalid lone UTF-16 surrogate.\"\n    })\n  }\n  let tree\n\n  try {\n    tree = parser.parse(source)\n  } catch (error) {\n    throw new SemantifoldDiagnostic({\n      cause: error instanceof Error ? error : undefined,\n      code: \"PARSE_ERROR\",\n      language: \"dart\",\n      location: moduleLocation(filename, source),\n      message: \"The qualified Dart parser could not produce a complete CST.\"\n    })\n  }\n  return new DartReader(filename, source).module(tree.rootNode)\n}\n"]}