semantifold 0.1.1 → 0.3.0

package/build/src/frontends/csharp.js

@@ -0,0 +1,708 @@
+// @ts-check
+import Parser from "tree-sitter";
+import CSharpLanguage from "tree-sitter-c-sharp/bindings/node/index.js";
+import { missingType, parseFailure, SemantifoldDiagnostic, unsupportedSyntax } from "../diagnostic.js";
+import { locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset } from "../semantic/location.js";
+import { withAdaptedOperation } from "../semantic/operators.js";
+import { withParserRanges } from "../semantic/provenance.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { validateParsedModule } from "../semantic/validate.js";
+import { sourceScalarType } from "./scalars.js";
+const parser = new Parser();
+parser.setLanguage(/** @type {import("tree-sitter").Language} */ ( /** @type {unknown} */(CSharpLanguage)));
+const immutableMarker = "// @semantifold-immutable";
+const checkedArithmetic = new WeakSet();
+const csharpReservedIdentifiers = new Set([
+    "abstract", "add", "alias", "allows", "and", "as", "ascending", "async", "await", "base", "bool", "break",
+    "by", "byte", "case", "catch", "char", "checked", "class", "const", "continue", "decimal", "default",
+    "delegate", "descending", "do", "double", "dynamic", "else", "enum", "equals", "event", "explicit", "extension", "extern",
+    "false", "field", "file", "finally", "fixed", "float", "for", "foreach", "from", "get", "global", "goto",
+    "group", "if", "implicit", "in", "init", "int", "interface", "internal", "into", "is", "join", "let", "lock",
+    "long", "managed", "nameof", "namespace", "new", "nint", "not", "notnull", "null", "nuint", "object", "on",
+    "operator", "or", "orderby", "out", "override", "params", "partial", "private", "protected", "public", "readonly",
+    "record", "ref", "remove", "required", "return", "sbyte", "scoped", "sealed", "select", "set", "short", "sizeof",
+    "stackalloc", "static", "string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong",
+    "unchecked", "unmanaged", "unsafe", "ushort", "using", "value", "var", "virtual", "void", "volatile", "when",
+    "where", "while", "with", "yield"
+]);
+const binaryOperations = new Map([
+    ["+", "Add"], ["-", "Subtract"], ["*", "Multiply"], ["==", "Equal"], ["!=", "NotEqual"],
+    ["<", "LessThan"], ["<=", "LessThanOrEqual"], [">", "GreaterThan"], [">=", "GreaterThanOrEqual"],
+    ["&&", "And"], ["||", "Or"]
+]);
+/** @typedef {{comments: import("tree-sitter").SyntaxNode[], usedImmutableMarkers: Set<import("tree-sitter").SyntaxNode>}} CSharpContext */
+/**
+ * Verifies one Tree-sitter binding index through the shared byte converter.
+ * @param {string} source - Complete source text.
+ * @param {number} index - Binding-reported UTF-16 index.
+ * @returns {number} Verified UTF-16 offset.
+ */
+function bindingIndexToUtf16Offset(source, index) {
+    if (!Number.isInteger(index) || index < 0 || index > source.length ||
+        index > 0 && index < source.length && /[\uD800-\uDBFF]/u.test(source[index - 1]) && /[\uDC00-\uDFFF]/u.test(source[index])) {
+        throw new RangeError(`Invalid Tree-sitter source index: ${index}`);
+    }
+    return utf8ByteOffsetToUtf16Offset(source, new TextEncoder().encode(source.slice(0, index)).length);
+}
+/**
+ * Finds the first unpaired UTF-16 surrogate.
+ * @param {string} source - Complete source text.
+ * @returns {number} Invalid offset, or -1.
+ */
+function firstLoneSurrogateOffset(source) {
+    for (let index = 0; index < source.length; index += 1) {
+        const unit = source.charCodeAt(index);
+        if (unit >= 0xD800 && unit <= 0xDBFF) {
+            const next = source.charCodeAt(index + 1);
+            if (next >= 0xDC00 && next <= 0xDFFF)
+                index += 1;
+            else
+                return index;
+        }
+        else if (unit >= 0xDC00 && unit <= 0xDFFF)
+            return index;
+    }
+    return -1;
+}
+/**
+ * Converts one binding range to a semantic source location.
+ * @param {import("tree-sitter").SyntaxNode} node - Parser node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").SourceLocation} Exact location.
+ */
+function nodeLocation(node, filename, source) {
+    return locationFromOffsets(filename, source, bindingIndexToUtf16Offset(source, node.startIndex), bindingIndexToUtf16Offset(source, node.endIndex));
+}
+/**
+ * Requires one named grammar field.
+ * @param {import("tree-sitter").SyntaxNode} node - Field owner.
+ * @param {string} field - Grammar field name.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("tree-sitter").SyntaxNode} Required child.
+ */
+function requiredField(node, field, filename, source) {
+    const child = node.childForFieldName(field);
+    if (!child)
+        return unsupportedSyntax("csharp", `${node.type} without ${field}`, nodeLocation(node, filename, source));
+    return child;
+}
+/**
+ * Traverses every parser child and rejects explicit or propagated recovery.
+ * @param {import("tree-sitter").SyntaxNode} node - Current parser node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {void}
+ */
+function validateParserTree(node, filename, source) {
+    if (node.hasError || node.isError || node.isMissing) {
+        throw new SemantifoldDiagnostic({
+            code: "PARSE_ERROR",
+            language: "csharp",
+            location: nodeLocation(node, filename, source),
+            message: `Tree-sitter exposed recovery at '${node.type}'.`
+        });
+    }
+    for (let index = 0; index < node.childCount; index += 1) {
+        const child = node.child(index);
+        if (!child)
+            throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`);
+        validateParserTree(child, filename, source);
+    }
+}
+/**
+ * Selects named semantic children while retaining comments in the parser tree.
+ * @param {import("tree-sitter").SyntaxNode} node - Parent parser node.
+ * @returns {import("tree-sitter").SyntaxNode[]} Non-comment named children.
+ */
+function semanticChildren(node) {
+    return node.namedChildren.filter((child) => child.type != "comment");
+}
+/**
+ * Validates one identifier against the exact C# source profile.
+ * @param {import("tree-sitter").SyntaxNode} node - Identifier node.
+ * @param {string} role - Diagnostic role.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {string} Accepted identifier.
+ */
+function identifier(node, role, filename, source) {
+    const name = node.text;
+    if (node.type != "identifier" || !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name) || csharpReservedIdentifiers.has(name)) {
+        return unsupportedSyntax("csharp", `${role} identifier '${name}'`, nodeLocation(node, filename, source));
+    }
+    return name;
+}
+/**
+ * Converts one exact supported scalar type.
+ * @param {import("tree-sitter").SyntaxNode | null} node - Type node, if present.
+ * @param {string} subject - Typed subject for diagnostics.
+ * @param {import("../semantic/types.js").SourceLocation} ownerLocation - Owning declaration location.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @param {boolean} [allowVar] - Whether inferred `var` produces MISSING_TYPE.
+ * @returns {import("../semantic/types.js").TypeReference} Semantic scalar type.
+ */
+function convertType(node, subject, ownerLocation, filename, source, allowVar = false) {
+    if (!node)
+        return missingType("csharp", subject, ownerLocation);
+    const location = nodeLocation(node, filename, source);
+    if (allowVar && node.text == "var")
+        return missingType("csharp", subject, ownerLocation);
+    const type = sourceScalarType("csharp", node.text, location);
+    if (!type || !["predefined_type", "qualified_name"].includes(node.type)) {
+        return unsupportedSyntax("csharp", `unsupported scalar type '${node.text}'`, location);
+    }
+    return type;
+}
+/**
+ * Finds exactly one accepted operator token owned by a parser node.
+ * @param {import("tree-sitter").SyntaxNode} node - Operation node.
+ * @param {Set<string>} spellings - Accepted operator spellings.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("tree-sitter").SyntaxNode} Operator token.
+ */
+function operatorToken(node, spellings, filename, source) {
+    const field = node.childForFieldName("operator");
+    const candidates = field ? [field] : node.children.filter((child) => !child.isNamed && spellings.has(child.type));
+    if (candidates.length != 1 || !spellings.has(candidates[0].type)) {
+        return unsupportedSyntax("csharp", `${node.type} operator`, nodeLocation(node, filename, source));
+    }
+    return candidates[0];
+}
+/**
+ * Converts one expression and records exact checked-wrapper ownership.
+ * @param {import("tree-sitter").SyntaxNode} node - Expression node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @param {boolean} [checkedRoot] - Whether the node is the direct checked-expression operand.
+ * @returns {import("../semantic/types.js").Expression} Semantic expression.
+ */
+function convertExpression(node, filename, source, checkedRoot = false) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type == "parenthesized_expression") {
+        const children = semanticChildren(node);
+        if (children.length != 1)
+            return unsupportedSyntax("csharp", node.type, location);
+        return convertExpression(children[0], filename, source);
+    }
+    if (node.type == "checked_expression") {
+        const children = semanticChildren(node);
+        const checkedTokens = node.children.filter((child) => !child.isNamed && child.type == "checked");
+        if (checkedTokens.length != 1 || children.length != 1 ||
+            !["binary_expression", "prefix_unary_expression"].includes(children[0].type)) {
+            return unsupportedSyntax("csharp", "checked expression shape", location);
+        }
+        const expression = convertExpression(children[0], filename, source, true);
+        checkedArithmetic.add(expression);
+        expression.location = location;
+        return expression;
+    }
+    if (node.type == "identifier") {
+        const name = identifier(node, "reference", filename, source);
+        return withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location, name }, { name: location });
+    }
+    if (node.type == "integer_literal") {
+        if (!/^(?:0|[1-9][0-9]*)L$/u.test(node.text))
+            return unsupportedSyntax("csharp", "noncanonical long literal", location);
+        const value = Number(BigInt(node.text.slice(0, -1)));
+        if (!Number.isSafeInteger(value))
+            return unsupportedSyntax("csharp", "non-safe integer literal", location);
+        return withParserRanges({ kind: /** @type {const} */ ("IntegerLiteral"), location, value }, { literal: location });
+    }
+    if (node.type == "boolean_literal") {
+        if (node.text != "true" && node.text != "false")
+            return unsupportedSyntax("csharp", "boolean literal", location);
+        return withParserRanges({ kind: /** @type {const} */ ("BooleanLiteral"), location, value: node.text == "true" }, { literal: location });
+    }
+    if (node.type == "string_literal") {
+        return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: decodeString(node, filename, source) }, {
+            literal: location
+        });
+    }
+    if (node.type == "prefix_unary_expression") {
+        const children = semanticChildren(node);
+        const operator = operatorToken(node, new Set(["!", "-"]), filename, source);
+        if (children.length != 1 || operator.type == "-" && !checkedRoot) {
+            return unsupportedSyntax("csharp", "unwrapped or malformed unary expression", location);
+        }
+        const expression = /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand: convertExpression(children[0], filename, source)
+        }, { operator: nodeLocation(operator, filename, source) }), operator.type == "!" ? "Not" : "Negate")));
+        if (checkedRoot)
+            checkedArithmetic.add(expression);
+        return expression;
+    }
+    if (node.type == "binary_expression") {
+        const leftNode = requiredField(node, "left", filename, source);
+        const rightNode = requiredField(node, "right", filename, source);
+        const operator = operatorToken(node, new Set(binaryOperations.keys()), filename, source);
+        const adapted = binaryOperations.get(operator.type);
+        if (!adapted || semanticChildren(node).length != 2 || ["-", "*"].includes(operator.type) && !checkedRoot) {
+            return unsupportedSyntax("csharp", "unwrapped or unsupported binary expression", location);
+        }
+        const expression = /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression",
+            left: convertExpression(leftNode, filename, source),
+            location,
+            right: convertExpression(rightNode, filename, source)
+        }, { operator: nodeLocation(operator, filename, source) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (adapted))));
+        if (checkedRoot)
+            checkedArithmetic.add(expression);
+        return expression;
+    }
+    if (node.type == "invocation_expression") {
+        const calleeNode = requiredField(node, "function", filename, source);
+        const argumentsNode = requiredField(node, "arguments", filename, source);
+        if (calleeNode.type != "identifier" || argumentsNode.type != "argument_list") {
+            return unsupportedSyntax("csharp", "qualified or dynamic call", location);
+        }
+        const arguments_ = /** @type {import("../semantic/types.js").Expression[]} */ (semanticChildren(argumentsNode).map((argument) => convertArgument(argument, filename, source)));
+        const callee = identifier(calleeNode, "callee", filename, source);
+        return withParserRanges({ arguments: arguments_, callee, kind: /** @type {const} */ ("CallExpression"), location }, {
+            callee: nodeLocation(calleeNode, filename, source)
+        });
+    }
+    return unsupportedSyntax("csharp", node.type, location);
+}
+/**
+ * Converts one positional argument.
+ * @param {import("tree-sitter").SyntaxNode} node - Argument node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").Expression} Semantic argument expression.
+ */
+function convertArgument(node, filename, source) {
+    const children = semanticChildren(node);
+    if (node.type != "argument" || children.length != 1 || node.children.some((child) => !child.isNamed && child.type == ":")) {
+        return unsupportedSyntax("csharp", "non-positional argument", nodeLocation(node, filename, source));
+    }
+    return convertExpression(children[0], filename, source);
+}
+/**
+ * Decodes one ordinary C# string literal without interpolation or raw forms.
+ * @param {import("tree-sitter").SyntaxNode} node - String literal node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {string} Decoded Unicode scalar string.
+ */
+function decodeString(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const text = node.text;
+    if (!text.startsWith("\"") || !text.endsWith("\"") || text.startsWith("\"\"\"") || /[\r\n]/u.test(text)) {
+        return unsupportedSyntax("csharp", "noncanonical string literal", location);
+    }
+    let decoded = "";
+    const simple = new Map([["\"", "\""], ["\\", "\\"], ["0", "\0"], ["a", "\u0007"], ["b", "\b"], ["f", "\f"],
+        ["n", "\n"], ["r", "\r"], ["t", "\t"], ["v", "\v"]]);
+    for (let index = 1; index < text.length - 1; index += 1) {
+        const character = text[index];
+        if (character != "\\") {
+            decoded += character;
+            continue;
+        }
+        const escape = text[++index];
+        if (escape === undefined)
+            return unsupportedSyntax("csharp", "invalid string escape", location);
+        if (simple.has(escape)) {
+            decoded += simple.get(escape);
+            continue;
+        }
+        const width = escape == "u" ? 4 : escape == "U" ? 8 : 0;
+        const digits = text.slice(index + 1, index + 1 + width);
+        if (!width || digits.length != width || !/^[0-9A-Fa-f]+$/u.test(digits)) {
+            return unsupportedSyntax("csharp", "unsupported string escape", location);
+        }
+        index += width;
+        const value = Number.parseInt(digits, 16);
+        if (escape == "U" && (value > 0x10FFFF || value >= 0xD800 && value <= 0xDFFF)) {
+            return unsupportedSyntax("csharp", "invalid Unicode string escape", location);
+        }
+        decoded += escape == "U" ? String.fromCodePoint(value) : String.fromCharCode(value);
+    }
+    if (!hasOnlyUnicodeScalars(decoded))
+        return unsupportedSyntax("csharp", "invalid Unicode string literal", location);
+    return decoded;
+}
+/**
+ * Converts one exact initialized local declaration.
+ * @param {import("tree-sitter").SyntaxNode} node - Local statement node.
+ * @param {CSharpContext} context - Comment-carrier state.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").LocalDeclaration} Semantic declaration.
+ */
+function convertLocal(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const declaration = semanticChildren(node)[0];
+    if (semanticChildren(node).length != 1 || declaration?.type != "variable_declaration") {
+        return unsupportedSyntax("csharp", node.type, location);
+    }
+    const typeNode = declaration.childForFieldName("type");
+    const declarators = semanticChildren(declaration).filter((child) => child.type == "variable_declarator");
+    if (declarators.length != 1 || semanticChildren(declaration).length != 2) {
+        return unsupportedSyntax("csharp", "local declaration shape", location);
+    }
+    const declarator = declarators[0];
+    const nameNode = requiredField(declarator, "name", filename, source);
+    const values = semanticChildren(declarator).filter((child) => child.id != nameNode.id);
+    if (values.length != 1)
+        return unsupportedSyntax("csharp", "local without one initializer", location);
+    const name = identifier(nameNode, "local", filename, source);
+    if (name == "System")
+        return unsupportedSyntax("csharp", "local captures System", nodeLocation(nameNode, filename, source));
+    const operator = operatorToken(declarator, new Set(["="]), filename, source);
+    const mutable = !takeImmutableMarker(node, context);
+    return withParserRanges({
+        initializer: convertExpression(values[0], filename, source),
+        kind: /** @type {const} */ ("LocalDeclaration"),
+        location,
+        mutable,
+        name,
+        type: convertType(typeNode, `Local '${name}'`, location, filename, source, true)
+    }, { name: nodeLocation(nameNode, filename, source), operator: nodeLocation(operator, filename, source) });
+}
+/**
+ * Claims an exactly adjacent immutable-local carrier if present.
+ * @param {import("tree-sitter").SyntaxNode} node - Local declaration node.
+ * @param {CSharpContext} context - Comment-carrier state.
+ * @returns {boolean} Whether the local is immutable.
+ */
+function takeImmutableMarker(node, context) {
+    const marker = context.comments.find((comment) => comment.text == immutableMarker &&
+        comment.endPosition.row + 1 == node.startPosition.row && comment.startPosition.column == node.startPosition.column);
+    if (!marker)
+        return false;
+    context.usedImmutableMarkers.add(marker);
+    return true;
+}
+/**
+ * Converts one supported C# statement.
+ * @param {import("tree-sitter").SyntaxNode} node - Statement node.
+ * @param {CSharpContext} context - Comment-carrier state.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").Statement} Semantic statement.
+ */
+function convertStatement(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type == "local_declaration_statement")
+        return convertLocal(node, context, filename, source);
+    if (node.type == "return_statement") {
+        const children = semanticChildren(node);
+        if (children.length != 1)
+            return unsupportedSyntax("csharp", "return without one expression", location);
+        return { expression: convertExpression(children[0], filename, source), kind: /** @type {const} */ ("ReturnStatement"), location };
+    }
+    if (node.type == "if_statement")
+        return convertIf(node, context, filename, source);
+    if (node.type == "expression_statement") {
+        const children = semanticChildren(node);
+        if (children.length != 1)
+            return unsupportedSyntax("csharp", node.type, location);
+        if (children[0].type == "assignment_expression")
+            return convertAssignment(children[0], filename, source, location);
+        return convertPrint(children[0], filename, source, location);
+    }
+    return unsupportedSyntax("csharp", node.type, location);
+}
+/**
+ * Converts one plain identifier assignment.
+ * @param {import("tree-sitter").SyntaxNode} node - Assignment expression node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @param {import("../semantic/types.js").SourceLocation} location - Owning statement location.
+ * @returns {import("../semantic/types.js").AssignmentStatement} Semantic assignment.
+ */
+function convertAssignment(node, filename, source, location) {
+    const left = requiredField(node, "left", filename, source);
+    const right = requiredField(node, "right", filename, source);
+    const operator = operatorToken(node, new Set(["="]), filename, source);
+    if (left.type != "identifier")
+        return unsupportedSyntax("csharp", "assignment target", nodeLocation(left, filename, source));
+    const name = identifier(left, "assignment target", filename, source);
+    const nameLocation = nodeLocation(left, filename, source);
+    return withParserRanges({
+        expression: convertExpression(right, filename, source),
+        kind: /** @type {const} */ ("AssignmentStatement"),
+        location,
+        target: withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: nameLocation, name }, { name: nameLocation })
+    }, { operator: nodeLocation(operator, filename, source) });
+}
+/**
+ * Converts the exact System.Console.WriteLine print scaffold.
+ * @param {import("tree-sitter").SyntaxNode} node - Invocation node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @param {import("../semantic/types.js").SourceLocation} location - Owning statement location.
+ * @returns {import("../semantic/types.js").PrintStatement} Semantic print statement.
+ */
+function convertPrint(node, filename, source, location) {
+    if (node.type != "invocation_expression")
+        return unsupportedSyntax("csharp", "expression statement other than print", nodeLocation(node, filename, source));
+    const callee = requiredField(node, "function", filename, source);
+    const argumentsNode = requiredField(node, "arguments", filename, source);
+    const arguments_ = semanticChildren(argumentsNode);
+    if (!isPrintReceiver(callee) || argumentsNode.type != "argument_list" || arguments_.length != 1) {
+        return unsupportedSyntax("csharp", "print call shape", nodeLocation(node, filename, source));
+    }
+    return { expression: convertArgument(arguments_[0], filename, source), kind: /** @type {const} */ ("PrintStatement"), location };
+}
+/**
+ * Recognizes only the fully qualified print receiver.
+ * @param {import("tree-sitter").SyntaxNode} node - Candidate callee.
+ * @returns {boolean} Whether the callee is the exact print receiver.
+ */
+function isPrintReceiver(node) {
+    if (node.type != "member_access_expression")
+        return false;
+    const outerExpression = node.childForFieldName("expression");
+    const outerName = node.childForFieldName("name");
+    if (outerName?.text != "WriteLine" || outerExpression?.type != "member_access_expression")
+        return false;
+    return outerExpression.childForFieldName("expression")?.type == "identifier" &&
+        outerExpression.childForFieldName("expression")?.text == "System" && outerExpression.childForFieldName("name")?.text == "Console";
+}
+/**
+ * Converts one braced conditional and optional alternate.
+ * @param {import("tree-sitter").SyntaxNode} node - If-statement node.
+ * @param {CSharpContext} context - Comment-carrier state.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").IfStatement} Semantic conditional.
+ */
+function convertIf(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const condition = requiredField(node, "condition", filename, source);
+    const consequence = requiredField(node, "consequence", filename, source);
+    const alternative = node.childForFieldName("alternative");
+    return {
+        ...(alternative ? { alternate: alternative.type == "if_statement"
+                ? { kind: /** @type {const} */ ("Block"), location: nodeLocation(alternative, filename, source),
+                    statements: [convertIf(alternative, context, filename, source)] }
+                : convertBlock(alternative, context, filename, source) } : {}),
+        condition: convertExpression(condition, filename, source),
+        consequent: convertBlock(consequence, context, filename, source),
+        kind: /** @type {const} */ ("IfStatement"),
+        location
+    };
+}
+/**
+ * Converts one lexical C# block.
+ * @param {import("tree-sitter").SyntaxNode} node - Block node.
+ * @param {CSharpContext} context - Comment-carrier state.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").Block} Semantic block.
+ */
+function convertBlock(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type != "block")
+        return unsupportedSyntax("csharp", node.type, location);
+    return { kind: /** @type {const} */ ("Block"), location,
+        statements: semanticChildren(node).map((statement) => convertStatement(statement, context, filename, source)) };
+}
+/**
+ * Converts one exact private static semantic method.
+ * @param {import("tree-sitter").SyntaxNode} node - Method node.
+ * @param {CSharpContext} context - Comment-carrier state.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+ */
+function convertFunction(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const children = semanticChildren(node);
+    const modifiers = children.filter((child) => child.type == "modifier");
+    if (node.type != "method_declaration" || modifiers.map(({ text }) => text).join(" ") != "private static" ||
+        children.length != 6 || node.childForFieldName("type_parameters") || node.childForFieldName("constraints") ||
+        !node.childForFieldName("body")) {
+        return unsupportedSyntax("csharp", "method scaffolding", location);
+    }
+    const nameNode = requiredField(node, "name", filename, source);
+    const parametersNode = requiredField(node, "parameters", filename, source);
+    const returnNode = requiredField(node, "returns", filename, source);
+    const bodyNode = requiredField(node, "body", filename, source);
+    const name = identifier(nameNode, "function", filename, source);
+    if (["Main", "Program", "System"].includes(name)) {
+        return unsupportedSyntax("csharp", `reserved semantic method '${name}'`, nodeLocation(nameNode, filename, source));
+    }
+    const parameterNodes = semanticChildren(parametersNode);
+    if (parameterNodes.length != 2 || parameterNodes.some((parameter) => parameter.type != "parameter")) {
+        return unsupportedSyntax("csharp", "function parameter count or shape", nodeLocation(parametersNode, filename, source));
+    }
+    const parameters = parameterNodes.map((parameterNode) => convertParameter(parameterNode, filename, source));
+    return withParserRanges({
+        body: convertBlock(bodyNode, context, filename, source),
+        kind: /** @type {const} */ ("FunctionDeclaration"),
+        location,
+        name,
+        parameters,
+        returnType: convertType(returnNode, `Function '${name}' return`, location, filename, source)
+    }, { name: nodeLocation(nameNode, filename, source) });
+}
+/**
+ * Converts one explicitly typed unmodified parameter.
+ * @param {import("tree-sitter").SyntaxNode} node - Parameter node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").Parameter} Semantic parameter.
+ */
+function convertParameter(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const nameNode = requiredField(node, "name", filename, source);
+    const typeNode = node.childForFieldName("type");
+    if (semanticChildren(node).length != 2)
+        return unsupportedSyntax("csharp", "parameter modifiers or defaults", location);
+    const name = identifier(nameNode, "parameter", filename, source);
+    if (name == "System")
+        return unsupportedSyntax("csharp", "parameter captures System", nodeLocation(nameNode, filename, source));
+    return withParserRanges({
+        kind: /** @type {const} */ ("Parameter"), location, name,
+        type: convertType(typeNode, `Parameter '${name}'`, location, filename, source)
+    }, { name: nodeLocation(nameNode, filename, source) });
+}
+/**
+ * Converts the exact final zero-argument Main method.
+ * @param {import("tree-sitter").SyntaxNode} node - Main method node.
+ * @param {CSharpContext} context - Comment-carrier state.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source text.
+ * @returns {import("../semantic/types.js").EntryPoint} Semantic entry point.
+ */
+function convertMain(node, context, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const children = semanticChildren(node);
+    const modifiers = children.filter((child) => child.type == "modifier");
+    const name = requiredField(node, "name", filename, source);
+    const returns = requiredField(node, "returns", filename, source);
+    const parameters = requiredField(node, "parameters", filename, source);
+    const body = requiredField(node, "body", filename, source);
+    if (children.length != 6 || modifiers.map(({ text }) => text).join(" ") != "private static" || name.text != "Main" || returns.text != "void" ||
+        semanticChildren(parameters).length != 0)
+        return unsupportedSyntax("csharp", "Main scaffolding", location);
+    return { body: convertBlock(body, context, filename, source), kind: /** @type {const} */ ("EntryPoint"), location };
+}
+/**
+ * Requires exactly one checked wrapper around every integer arithmetic root.
+ * @param {import("../semantic/types.js").SemanticModule} module - Resolved semantic module.
+ * @returns {void}
+ */
+function validateCheckedArithmetic(module) {
+    /** @type {import("../semantic/types.js").Expression[]} */
+    const expressions = [];
+    /**
+     * Collects expressions recursively.
+     * @param {import("../semantic/types.js").Expression} expression - Current expression.
+     * @returns {void}
+     */
+    const visitExpression = (expression) => {
+        expressions.push(expression);
+        if (expression.kind == "UnaryExpression")
+            visitExpression(expression.operand);
+        else if (expression.kind == "BinaryExpression") {
+            visitExpression(expression.left);
+            visitExpression(expression.right);
+        }
+        else if (expression.kind == "CallExpression")
+            expression.arguments.forEach(visitExpression);
+    };
+    /**
+     * Collects expressions from a semantic block.
+     * @param {import("../semantic/types.js").Block} block - Current block.
+     * @returns {void}
+     */
+    const visitBlock = (block) => block.statements.forEach((statement) => {
+        if (statement.kind == "LocalDeclaration")
+            visitExpression(statement.initializer);
+        else if (statement.kind == "AssignmentStatement" || statement.kind == "PrintStatement" || statement.kind == "ReturnStatement") {
+            visitExpression(statement.expression);
+        }
+        else {
+            visitExpression(statement.condition);
+            visitBlock(statement.consequent);
+            if (statement.alternate)
+                visitBlock(statement.alternate);
+        }
+    });
+    module.functions.forEach((declaration) => visitBlock(declaration.body));
+    visitBlock(module.entryPoint.body);
+    for (const expression of expressions) {
+        const arithmetic = expression.kind == "UnaryExpression" && expression.operation == "IntegerNegate" ||
+            expression.kind == "BinaryExpression" && ["IntegerAdd", "IntegerSubtract", "IntegerMultiply"].includes(expression.operation);
+        if (arithmetic != checkedArithmetic.has(expression)) {
+            return unsupportedSyntax("csharp", arithmetic ? "integer arithmetic without exact checked wrapper" : "checked non-integer expression", expression.location);
+        }
+    }
+}
+/**
+ * Parses the strict Task 017 C# profile.
+ * @param {{filename: string, source: string}} input - Parser input.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parseCSharp({ filename, source }) {
+    if (!hasOnlyUnicodeScalars(source)) {
+        const invalidOffset = firstLoneSurrogateOffset(source);
+        throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "csharp",
+            location: locationFromOffsets(filename, source, invalidOffset, invalidOffset + 1),
+            message: "C# source contains an invalid lone UTF-16 surrogate." });
+    }
+    let tree;
+    try {
+        tree = parser.parse(source);
+    }
+    catch (error) {
+        return parseFailure("csharp", error);
+    }
+    const root = tree.rootNode;
+    validateParserTree(root, filename, source);
+    if (root.type != "compilation_unit")
+        throw new Error(`Tree-sitter returned C# root '${root.type}'.`);
+    const children = semanticChildren(root);
+    const location = moduleLocation(filename, source);
+    if (children.length != 3 || children[0].type != "preproc_nullable" ||
+        !/^#nullable enable(?:(?:\r\n|\n|\r))+$/u.test(children[0].text) ||
+        children[1].type != "file_scoped_namespace_declaration" || children[2].type != "class_declaration") {
+        return unsupportedSyntax("csharp", "compilation-unit scaffolding", location);
+    }
+    const namespaceName = requiredField(children[1], "name", filename, source);
+    if (namespaceName.text != "Semantifold.Generated") {
+        return unsupportedSyntax("csharp", "namespace scaffolding", nodeLocation(children[1], filename, source));
+    }
+    const classNode = children[2];
+    const className = requiredField(classNode, "name", filename, source);
+    const classBody = requiredField(classNode, "body", filename, source);
+    const classChildren = semanticChildren(classNode);
+    const classModifiers = classChildren.filter((child) => child.type == "modifier");
+    if (classChildren.length != 4 || className.text != "Program" ||
+        classModifiers.map(({ text }) => text).join(" ") != "internal static") {
+        return unsupportedSyntax("csharp", "Program class scaffolding", nodeLocation(classNode, filename, source));
+    }
+    const members = semanticChildren(classBody);
+    if (members.length < 2 || members.some((member) => member.type != "method_declaration")) {
+        return unsupportedSyntax("csharp", "Program members", nodeLocation(classBody, filename, source));
+    }
+    const mainNodes = members.filter((member) => member.childForFieldName("name")?.text == "Main");
+    if (mainNodes.length != 1 || members.at(-1)?.id != mainNodes[0].id) {
+        return unsupportedSyntax("csharp", "Main ordering", nodeLocation(classBody, filename, source));
+    }
+    const comments = root.descendantsOfType("comment");
+    const context = { comments, usedImmutableMarkers: new Set() };
+    const module = {
+        entryPoint: convertMain(mainNodes[0], context, filename, source),
+        functions: members.slice(0, -1).map((member) => convertFunction(member, context, filename, source)),
+        kind: /** @type {const} */ ("Module"),
+        location
+    };
+    const unusedMarker = comments.find((comment) => comment.text == immutableMarker && !context.usedImmutableMarkers.has(comment));
+    if (unusedMarker)
+        return unsupportedSyntax("csharp", "unattached immutable marker", nodeLocation(unusedMarker, filename, source));
+    validateParsedModule(module, "csharp");
+    validateCheckedArithmetic(module);
+    return module;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"csharp.js","sourceRoot":"","sources":["../../../src/frontends/csharp.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Parser from \"tree-sitter\"\nimport CSharpLanguage from \"tree-sitter-c-sharp/bindings/node/index.js\"\nimport {missingType, parseFailure, SemantifoldDiagnostic, unsupportedSyntax} from \"../diagnostic.js\"\nimport {locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset} from \"../semantic/location.js\"\nimport {withAdaptedOperation} from \"../semantic/operators.js\"\nimport {withParserRanges} from \"../semantic/provenance.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {validateParsedModule} from \"../semantic/validate.js\"\nimport {sourceScalarType} from \"./scalars.js\"\n\nconst parser = new Parser()\n\nparser.setLanguage(/** @type {import(\"tree-sitter\").Language} */ (/** @type {unknown} */ (CSharpLanguage)))\n\nconst immutableMarker = \"// @semantifold-immutable\"\nconst checkedArithmetic = new WeakSet()\nconst csharpReservedIdentifiers = new Set([\n  \"abstract\", \"add\", \"alias\", \"allows\", \"and\", \"as\", \"ascending\", \"async\", \"await\", \"base\", \"bool\", \"break\",\n  \"by\", \"byte\", \"case\", \"catch\", \"char\", \"checked\", \"class\", \"const\", \"continue\", \"decimal\", \"default\",\n  \"delegate\", \"descending\", \"do\", \"double\", \"dynamic\", \"else\", \"enum\", \"equals\", \"event\", \"explicit\", \"extension\", \"extern\",\n  \"false\", \"field\", \"file\", \"finally\", \"fixed\", \"float\", \"for\", \"foreach\", \"from\", \"get\", \"global\", \"goto\",\n  \"group\", \"if\", \"implicit\", \"in\", \"init\", \"int\", \"interface\", \"internal\", \"into\", \"is\", \"join\", \"let\", \"lock\",\n  \"long\", \"managed\", \"nameof\", \"namespace\", \"new\", \"nint\", \"not\", \"notnull\", \"null\", \"nuint\", \"object\", \"on\",\n  \"operator\", \"or\", \"orderby\", \"out\", \"override\", \"params\", \"partial\", \"private\", \"protected\", \"public\", \"readonly\",\n  \"record\", \"ref\", \"remove\", \"required\", \"return\", \"sbyte\", \"scoped\", \"sealed\", \"select\", \"set\", \"short\", \"sizeof\",\n  \"stackalloc\", \"static\", \"string\", \"struct\", \"switch\", \"this\", \"throw\", \"true\", \"try\", \"typeof\", \"uint\", \"ulong\",\n  \"unchecked\", \"unmanaged\", \"unsafe\", \"ushort\", \"using\", \"value\", \"var\", \"virtual\", \"void\", \"volatile\", \"when\",\n  \"where\", \"while\", \"with\", \"yield\"\n])\nconst binaryOperations = new Map([\n  [\"+\", \"Add\"], [\"-\", \"Subtract\"], [\"*\", \"Multiply\"], [\"==\", \"Equal\"], [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"], [\"<=\", \"LessThanOrEqual\"], [\">\", \"GreaterThan\"], [\">=\", \"GreaterThanOrEqual\"],\n  [\"&&\", \"And\"], [\"||\", \"Or\"]\n])\n\n/** @typedef {{comments: import(\"tree-sitter\").SyntaxNode[], usedImmutableMarkers: Set<import(\"tree-sitter\").SyntaxNode>}} CSharpContext */\n\n/**\n * Verifies one Tree-sitter binding index through the shared byte converter.\n * @param {string} source - Complete source text.\n * @param {number} index - Binding-reported UTF-16 index.\n * @returns {number} Verified UTF-16 offset.\n */\nfunction bindingIndexToUtf16Offset(source, index) {\n  if (!Number.isInteger(index) || index < 0 || index > source.length ||\n    index > 0 && index < source.length && /[\\uD800-\\uDBFF]/u.test(source[index - 1]) && /[\\uDC00-\\uDFFF]/u.test(source[index])) {\n    throw new RangeError(`Invalid Tree-sitter source index: ${index}`)\n  }\n  return utf8ByteOffsetToUtf16Offset(source, new TextEncoder().encode(source.slice(0, index)).length)\n}\n\n/**\n * Finds the first unpaired UTF-16 surrogate.\n * @param {string} source - Complete source text.\n * @returns {number} Invalid offset, or -1.\n */\nfunction firstLoneSurrogateOffset(source) {\n  for (let index = 0; index < source.length; index += 1) {\n    const unit = source.charCodeAt(index)\n\n    if (unit >= 0xD800 && unit <= 0xDBFF) {\n      const next = source.charCodeAt(index + 1)\n\n      if (next >= 0xDC00 && next <= 0xDFFF) index += 1\n      else return index\n    } else if (unit >= 0xDC00 && unit <= 0xDFFF) return index\n  }\n  return -1\n}\n\n/**\n * Converts one binding range to a semantic source location.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Parser node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Exact location.\n */\nfunction nodeLocation(node, filename, source) {\n  return locationFromOffsets(filename, source, bindingIndexToUtf16Offset(source, node.startIndex),\n    bindingIndexToUtf16Offset(source, node.endIndex))\n}\n\n/**\n * Requires one named grammar field.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Field owner.\n * @param {string} field - Grammar field name.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"tree-sitter\").SyntaxNode} Required child.\n */\nfunction requiredField(node, field, filename, source) {\n  const child = node.childForFieldName(field)\n\n  if (!child) return unsupportedSyntax(\"csharp\", `${node.type} without ${field}`, nodeLocation(node, filename, source))\n  return child\n}\n\n/**\n * Traverses every parser child and rejects explicit or propagated recovery.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Current parser node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {void}\n */\nfunction validateParserTree(node, filename, source) {\n  if (node.hasError || node.isError || node.isMissing) {\n    throw new SemantifoldDiagnostic({\n      code: \"PARSE_ERROR\",\n      language: \"csharp\",\n      location: nodeLocation(node, filename, source),\n      message: `Tree-sitter exposed recovery at '${node.type}'.`\n    })\n  }\n  for (let index = 0; index < node.childCount; index += 1) {\n    const child = node.child(index)\n\n    if (!child) throw new Error(`Tree-sitter omitted child ${index} of ${node.type}.`)\n    validateParserTree(child, filename, source)\n  }\n}\n\n/**\n * Selects named semantic children while retaining comments in the parser tree.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Parent parser node.\n * @returns {import(\"tree-sitter\").SyntaxNode[]} Non-comment named children.\n */\nfunction semanticChildren(node) {\n  return node.namedChildren.filter((child) => child.type != \"comment\")\n}\n\n/**\n * Validates one identifier against the exact C# source profile.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Identifier node.\n * @param {string} role - Diagnostic role.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {string} Accepted identifier.\n */\nfunction identifier(node, role, filename, source) {\n  const name = node.text\n\n  if (node.type != \"identifier\" || !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name) || csharpReservedIdentifiers.has(name)) {\n    return unsupportedSyntax(\"csharp\", `${role} identifier '${name}'`, nodeLocation(node, filename, source))\n  }\n  return name\n}\n\n/**\n * Converts one exact supported scalar type.\n * @param {import(\"tree-sitter\").SyntaxNode | null} node - Type node, if present.\n * @param {string} subject - Typed subject for diagnostics.\n * @param {import(\"../semantic/types.js\").SourceLocation} ownerLocation - Owning declaration location.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @param {boolean} [allowVar] - Whether inferred `var` produces MISSING_TYPE.\n * @returns {import(\"../semantic/types.js\").TypeReference} Semantic scalar type.\n */\nfunction convertType(node, subject, ownerLocation, filename, source, allowVar = false) {\n  if (!node) return missingType(\"csharp\", subject, ownerLocation)\n  const location = nodeLocation(node, filename, source)\n\n  if (allowVar && node.text == \"var\") return missingType(\"csharp\", subject, ownerLocation)\n  const type = sourceScalarType(\"csharp\", node.text, location)\n\n  if (!type || ![\"predefined_type\", \"qualified_name\"].includes(node.type)) {\n    return unsupportedSyntax(\"csharp\", `unsupported scalar type '${node.text}'`, location)\n  }\n  return type\n}\n\n/**\n * Finds exactly one accepted operator token owned by a parser node.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Operation node.\n * @param {Set<string>} spellings - Accepted operator spellings.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"tree-sitter\").SyntaxNode} Operator token.\n */\nfunction operatorToken(node, spellings, filename, source) {\n  const field = node.childForFieldName(\"operator\")\n  const candidates = field ? [field] : node.children.filter((child) => !child.isNamed && spellings.has(child.type))\n\n  if (candidates.length != 1 || !spellings.has(candidates[0].type)) {\n    return unsupportedSyntax(\"csharp\", `${node.type} operator`, nodeLocation(node, filename, source))\n  }\n  return candidates[0]\n}\n\n/**\n * Converts one expression and records exact checked-wrapper ownership.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Expression node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @param {boolean} [checkedRoot] - Whether the node is the direct checked-expression operand.\n * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n */\nfunction convertExpression(node, filename, source, checkedRoot = false) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type == \"parenthesized_expression\") {\n    const children = semanticChildren(node)\n\n    if (children.length != 1) return unsupportedSyntax(\"csharp\", node.type, location)\n    return convertExpression(children[0], filename, source)\n  }\n  if (node.type == \"checked_expression\") {\n    const children = semanticChildren(node)\n    const checkedTokens = node.children.filter((child) => !child.isNamed && child.type == \"checked\")\n\n    if (checkedTokens.length != 1 || children.length != 1 ||\n      ![\"binary_expression\", \"prefix_unary_expression\"].includes(children[0].type)) {\n      return unsupportedSyntax(\"csharp\", \"checked expression shape\", location)\n    }\n    const expression = convertExpression(children[0], filename, source, true)\n\n    checkedArithmetic.add(expression)\n    expression.location = location\n    return expression\n  }\n  if (node.type == \"identifier\") {\n    const name = identifier(node, \"reference\", filename, source)\n\n    return withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location, name}, {name: location})\n  }\n  if (node.type == \"integer_literal\") {\n    if (!/^(?:0|[1-9][0-9]*)L$/u.test(node.text)) return unsupportedSyntax(\"csharp\", \"noncanonical long literal\", location)\n    const value = Number(BigInt(node.text.slice(0, -1)))\n\n    if (!Number.isSafeInteger(value)) return unsupportedSyntax(\"csharp\", \"non-safe integer literal\", location)\n    return withParserRanges({kind: /** @type {const} */ (\"IntegerLiteral\"), location, value}, {literal: location})\n  }\n  if (node.type == \"boolean_literal\") {\n    if (node.text != \"true\" && node.text != \"false\") return unsupportedSyntax(\"csharp\", \"boolean literal\", location)\n    return withParserRanges({kind: /** @type {const} */ (\"BooleanLiteral\"), location, value: node.text == \"true\"}, {literal: location})\n  }\n  if (node.type == \"string_literal\") {\n    return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: decodeString(node, filename, source)}, {\n      literal: location\n    })\n  }\n  if (node.type == \"prefix_unary_expression\") {\n    const children = semanticChildren(node)\n    const operator = operatorToken(node, new Set([\"!\", \"-\"]), filename, source)\n\n    if (children.length != 1 || operator.type == \"-\" && !checkedRoot) {\n      return unsupportedSyntax(\"csharp\", \"unwrapped or malformed unary expression\", location)\n    }\n    const expression = /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand: convertExpression(children[0], filename, source)\n    }, {operator: nodeLocation(operator, filename, source)}), operator.type == \"!\" ? \"Not\" : \"Negate\")))\n\n    if (checkedRoot) checkedArithmetic.add(expression)\n    return expression\n  }\n  if (node.type == \"binary_expression\") {\n    const leftNode = requiredField(node, \"left\", filename, source)\n    const rightNode = requiredField(node, \"right\", filename, source)\n    const operator = operatorToken(node, new Set(binaryOperations.keys()), filename, source)\n    const adapted = binaryOperations.get(operator.type)\n\n    if (!adapted || semanticChildren(node).length != 2 || [\"-\", \"*\"].includes(operator.type) && !checkedRoot) {\n      return unsupportedSyntax(\"csharp\", \"unwrapped or unsupported binary expression\", location)\n    }\n    const expression = /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\",\n      left: convertExpression(leftNode, filename, source),\n      location,\n      right: convertExpression(rightNode, filename, source)\n    }, {operator: nodeLocation(operator, filename, source)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (adapted))))\n\n    if (checkedRoot) checkedArithmetic.add(expression)\n    return expression\n  }\n  if (node.type == \"invocation_expression\") {\n    const calleeNode = requiredField(node, \"function\", filename, source)\n    const argumentsNode = requiredField(node, \"arguments\", filename, source)\n\n    if (calleeNode.type != \"identifier\" || argumentsNode.type != \"argument_list\") {\n      return unsupportedSyntax(\"csharp\", \"qualified or dynamic call\", location)\n    }\n    const arguments_ = /** @type {import(\"../semantic/types.js\").Expression[]} */ (\n      semanticChildren(argumentsNode).map((argument) => convertArgument(argument, filename, source)))\n    const callee = identifier(calleeNode, \"callee\", filename, source)\n\n    return withParserRanges({arguments: arguments_, callee, kind: /** @type {const} */ (\"CallExpression\"), location}, {\n      callee: nodeLocation(calleeNode, filename, source)\n    })\n  }\n  return unsupportedSyntax(\"csharp\", node.type, location)\n}\n\n/**\n * Converts one positional argument.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Argument node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").Expression} Semantic argument expression.\n */\nfunction convertArgument(node, filename, source) {\n  const children = semanticChildren(node)\n\n  if (node.type != \"argument\" || children.length != 1 || node.children.some((child) => !child.isNamed && child.type == \":\")) {\n    return unsupportedSyntax(\"csharp\", \"non-positional argument\", nodeLocation(node, filename, source))\n  }\n  return convertExpression(children[0], filename, source)\n}\n\n/**\n * Decodes one ordinary C# string literal without interpolation or raw forms.\n * @param {import(\"tree-sitter\").SyntaxNode} node - String literal node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {string} Decoded Unicode scalar string.\n */\nfunction decodeString(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const text = node.text\n\n  if (!text.startsWith(\"\\\"\") || !text.endsWith(\"\\\"\") || text.startsWith(\"\\\"\\\"\\\"\") || /[\\r\\n]/u.test(text)) {\n    return unsupportedSyntax(\"csharp\", \"noncanonical string literal\", location)\n  }\n  let decoded = \"\"\n  const simple = new Map([[\"\\\"\", \"\\\"\"], [\"\\\\\", \"\\\\\"], [\"0\", \"\\0\"], [\"a\", \"\\u0007\"], [\"b\", \"\\b\"], [\"f\", \"\\f\"],\n    [\"n\", \"\\n\"], [\"r\", \"\\r\"], [\"t\", \"\\t\"], [\"v\", \"\\v\"]])\n\n  for (let index = 1; index < text.length - 1; index += 1) {\n    const character = text[index]\n\n    if (character != \"\\\\\") {\n      decoded += character\n      continue\n    }\n    const escape = text[++index]\n\n    if (escape === undefined) return unsupportedSyntax(\"csharp\", \"invalid string escape\", location)\n    if (simple.has(escape)) {\n      decoded += simple.get(escape)\n      continue\n    }\n    const width = escape == \"u\" ? 4 : escape == \"U\" ? 8 : 0\n    const digits = text.slice(index + 1, index + 1 + width)\n\n    if (!width || digits.length != width || !/^[0-9A-Fa-f]+$/u.test(digits)) {\n      return unsupportedSyntax(\"csharp\", \"unsupported string escape\", location)\n    }\n    index += width\n    const value = Number.parseInt(digits, 16)\n\n    if (escape == \"U\" && (value > 0x10FFFF || value >= 0xD800 && value <= 0xDFFF)) {\n      return unsupportedSyntax(\"csharp\", \"invalid Unicode string escape\", location)\n    }\n    decoded += escape == \"U\" ? String.fromCodePoint(value) : String.fromCharCode(value)\n  }\n  if (!hasOnlyUnicodeScalars(decoded)) return unsupportedSyntax(\"csharp\", \"invalid Unicode string literal\", location)\n  return decoded\n}\n\n/**\n * Converts one exact initialized local declaration.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Local statement node.\n * @param {CSharpContext} context - Comment-carrier state.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").LocalDeclaration} Semantic declaration.\n */\nfunction convertLocal(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const declaration = semanticChildren(node)[0]\n\n  if (semanticChildren(node).length != 1 || declaration?.type != \"variable_declaration\") {\n    return unsupportedSyntax(\"csharp\", node.type, location)\n  }\n  const typeNode = declaration.childForFieldName(\"type\")\n  const declarators = semanticChildren(declaration).filter((child) => child.type == \"variable_declarator\")\n\n  if (declarators.length != 1 || semanticChildren(declaration).length != 2) {\n    return unsupportedSyntax(\"csharp\", \"local declaration shape\", location)\n  }\n  const declarator = declarators[0]\n  const nameNode = requiredField(declarator, \"name\", filename, source)\n  const values = semanticChildren(declarator).filter((child) => child.id != nameNode.id)\n\n  if (values.length != 1) return unsupportedSyntax(\"csharp\", \"local without one initializer\", location)\n  const name = identifier(nameNode, \"local\", filename, source)\n\n  if (name == \"System\") return unsupportedSyntax(\"csharp\", \"local captures System\", nodeLocation(nameNode, filename, source))\n  const operator = operatorToken(declarator, new Set([\"=\"]), filename, source)\n  const mutable = !takeImmutableMarker(node, context)\n\n  return withParserRanges({\n    initializer: convertExpression(values[0], filename, source),\n    kind: /** @type {const} */ (\"LocalDeclaration\"),\n    location,\n    mutable,\n    name,\n    type: convertType(typeNode, `Local '${name}'`, location, filename, source, true)\n  }, {name: nodeLocation(nameNode, filename, source), operator: nodeLocation(operator, filename, source)})\n}\n\n/**\n * Claims an exactly adjacent immutable-local carrier if present.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Local declaration node.\n * @param {CSharpContext} context - Comment-carrier state.\n * @returns {boolean} Whether the local is immutable.\n */\nfunction takeImmutableMarker(node, context) {\n  const marker = context.comments.find((comment) => comment.text == immutableMarker &&\n    comment.endPosition.row + 1 == node.startPosition.row && comment.startPosition.column == node.startPosition.column)\n\n  if (!marker) return false\n  context.usedImmutableMarkers.add(marker)\n  return true\n}\n\n/**\n * Converts one supported C# statement.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Statement node.\n * @param {CSharpContext} context - Comment-carrier state.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").Statement} Semantic statement.\n */\nfunction convertStatement(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type == \"local_declaration_statement\") return convertLocal(node, context, filename, source)\n  if (node.type == \"return_statement\") {\n    const children = semanticChildren(node)\n\n    if (children.length != 1) return unsupportedSyntax(\"csharp\", \"return without one expression\", location)\n    return {expression: convertExpression(children[0], filename, source), kind: /** @type {const} */ (\"ReturnStatement\"), location}\n  }\n  if (node.type == \"if_statement\") return convertIf(node, context, filename, source)\n  if (node.type == \"expression_statement\") {\n    const children = semanticChildren(node)\n\n    if (children.length != 1) return unsupportedSyntax(\"csharp\", node.type, location)\n    if (children[0].type == \"assignment_expression\") return convertAssignment(children[0], filename, source, location)\n    return convertPrint(children[0], filename, source, location)\n  }\n  return unsupportedSyntax(\"csharp\", node.type, location)\n}\n\n/**\n * Converts one plain identifier assignment.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Assignment expression node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Owning statement location.\n * @returns {import(\"../semantic/types.js\").AssignmentStatement} Semantic assignment.\n */\nfunction convertAssignment(node, filename, source, location) {\n  const left = requiredField(node, \"left\", filename, source)\n  const right = requiredField(node, \"right\", filename, source)\n  const operator = operatorToken(node, new Set([\"=\"]), filename, source)\n\n  if (left.type != \"identifier\") return unsupportedSyntax(\"csharp\", \"assignment target\", nodeLocation(left, filename, source))\n  const name = identifier(left, \"assignment target\", filename, source)\n  const nameLocation = nodeLocation(left, filename, source)\n\n  return withParserRanges({\n    expression: convertExpression(right, filename, source),\n    kind: /** @type {const} */ (\"AssignmentStatement\"),\n    location,\n    target: withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: nameLocation, name}, {name: nameLocation})\n  }, {operator: nodeLocation(operator, filename, source)})\n}\n\n/**\n * Converts the exact System.Console.WriteLine print scaffold.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Invocation node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Owning statement location.\n * @returns {import(\"../semantic/types.js\").PrintStatement} Semantic print statement.\n */\nfunction convertPrint(node, filename, source, location) {\n  if (node.type != \"invocation_expression\") return unsupportedSyntax(\"csharp\", \"expression statement other than print\", nodeLocation(node, filename, source))\n  const callee = requiredField(node, \"function\", filename, source)\n  const argumentsNode = requiredField(node, \"arguments\", filename, source)\n  const arguments_ = semanticChildren(argumentsNode)\n\n  if (!isPrintReceiver(callee) || argumentsNode.type != \"argument_list\" || arguments_.length != 1) {\n    return unsupportedSyntax(\"csharp\", \"print call shape\", nodeLocation(node, filename, source))\n  }\n  return {expression: convertArgument(arguments_[0], filename, source), kind: /** @type {const} */ (\"PrintStatement\"), location}\n}\n\n/**\n * Recognizes only the fully qualified print receiver.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Candidate callee.\n * @returns {boolean} Whether the callee is the exact print receiver.\n */\nfunction isPrintReceiver(node) {\n  if (node.type != \"member_access_expression\") return false\n  const outerExpression = node.childForFieldName(\"expression\")\n  const outerName = node.childForFieldName(\"name\")\n\n  if (outerName?.text != \"WriteLine\" || outerExpression?.type != \"member_access_expression\") return false\n  return outerExpression.childForFieldName(\"expression\")?.type == \"identifier\" &&\n    outerExpression.childForFieldName(\"expression\")?.text == \"System\" && outerExpression.childForFieldName(\"name\")?.text == \"Console\"\n}\n\n/**\n * Converts one braced conditional and optional alternate.\n * @param {import(\"tree-sitter\").SyntaxNode} node - If-statement node.\n * @param {CSharpContext} context - Comment-carrier state.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").IfStatement} Semantic conditional.\n */\nfunction convertIf(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const condition = requiredField(node, \"condition\", filename, source)\n  const consequence = requiredField(node, \"consequence\", filename, source)\n  const alternative = node.childForFieldName(\"alternative\")\n\n  return {\n    ...(alternative ? {alternate: alternative.type == \"if_statement\"\n      ? {kind: /** @type {const} */ (\"Block\"), location: nodeLocation(alternative, filename, source),\n          statements: [convertIf(alternative, context, filename, source)]}\n      : convertBlock(alternative, context, filename, source)} : {}),\n    condition: convertExpression(condition, filename, source),\n    consequent: convertBlock(consequence, context, filename, source),\n    kind: /** @type {const} */ (\"IfStatement\"),\n    location\n  }\n}\n\n/**\n * Converts one lexical C# block.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Block node.\n * @param {CSharpContext} context - Comment-carrier state.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n */\nfunction convertBlock(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type != \"block\") return unsupportedSyntax(\"csharp\", node.type, location)\n  return {kind: /** @type {const} */ (\"Block\"), location,\n    statements: semanticChildren(node).map((statement) => convertStatement(statement, context, filename, source))}\n}\n\n/**\n * Converts one exact private static semantic method.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Method node.\n * @param {CSharpContext} context - Comment-carrier state.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n */\nfunction convertFunction(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const children = semanticChildren(node)\n  const modifiers = children.filter((child) => child.type == \"modifier\")\n\n  if (node.type != \"method_declaration\" || modifiers.map(({text}) => text).join(\" \") != \"private static\" ||\n    children.length != 6 || node.childForFieldName(\"type_parameters\") || node.childForFieldName(\"constraints\") ||\n    !node.childForFieldName(\"body\")) {\n    return unsupportedSyntax(\"csharp\", \"method scaffolding\", location)\n  }\n  const nameNode = requiredField(node, \"name\", filename, source)\n  const parametersNode = requiredField(node, \"parameters\", filename, source)\n  const returnNode = requiredField(node, \"returns\", filename, source)\n  const bodyNode = requiredField(node, \"body\", filename, source)\n  const name = identifier(nameNode, \"function\", filename, source)\n\n  if ([\"Main\", \"Program\", \"System\"].includes(name)) {\n    return unsupportedSyntax(\"csharp\", `reserved semantic method '${name}'`, nodeLocation(nameNode, filename, source))\n  }\n  const parameterNodes = semanticChildren(parametersNode)\n\n  if (parameterNodes.length != 2 || parameterNodes.some((parameter) => parameter.type != \"parameter\")) {\n    return unsupportedSyntax(\"csharp\", \"function parameter count or shape\", nodeLocation(parametersNode, filename, source))\n  }\n  const parameters = parameterNodes.map((parameterNode) => convertParameter(parameterNode, filename, source))\n\n  return withParserRanges({\n    body: convertBlock(bodyNode, context, filename, source),\n    kind: /** @type {const} */ (\"FunctionDeclaration\"),\n    location,\n    name,\n    parameters,\n    returnType: convertType(returnNode, `Function '${name}' return`, location, filename, source)\n  }, {name: nodeLocation(nameNode, filename, source)})\n}\n\n/**\n * Converts one explicitly typed unmodified parameter.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Parameter node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").Parameter} Semantic parameter.\n */\nfunction convertParameter(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const nameNode = requiredField(node, \"name\", filename, source)\n  const typeNode = node.childForFieldName(\"type\")\n\n  if (semanticChildren(node).length != 2) return unsupportedSyntax(\"csharp\", \"parameter modifiers or defaults\", location)\n  const name = identifier(nameNode, \"parameter\", filename, source)\n\n  if (name == \"System\") return unsupportedSyntax(\"csharp\", \"parameter captures System\", nodeLocation(nameNode, filename, source))\n  return withParserRanges({\n    kind: /** @type {const} */ (\"Parameter\"), location, name,\n    type: convertType(typeNode, `Parameter '${name}'`, location, filename, source)\n  }, {name: nodeLocation(nameNode, filename, source)})\n}\n\n/**\n * Converts the exact final zero-argument Main method.\n * @param {import(\"tree-sitter\").SyntaxNode} node - Main method node.\n * @param {CSharpContext} context - Comment-carrier state.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source text.\n * @returns {import(\"../semantic/types.js\").EntryPoint} Semantic entry point.\n */\nfunction convertMain(node, context, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const children = semanticChildren(node)\n  const modifiers = children.filter((child) => child.type == \"modifier\")\n  const name = requiredField(node, \"name\", filename, source)\n  const returns = requiredField(node, \"returns\", filename, source)\n  const parameters = requiredField(node, \"parameters\", filename, source)\n  const body = requiredField(node, \"body\", filename, source)\n\n  if (children.length != 6 || modifiers.map(({text}) => text).join(\" \") != \"private static\" || name.text != \"Main\" || returns.text != \"void\" ||\n    semanticChildren(parameters).length != 0) return unsupportedSyntax(\"csharp\", \"Main scaffolding\", location)\n  return {body: convertBlock(body, context, filename, source), kind: /** @type {const} */ (\"EntryPoint\"), location}\n}\n\n/**\n * Requires exactly one checked wrapper around every integer arithmetic root.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Resolved semantic module.\n * @returns {void}\n */\nfunction validateCheckedArithmetic(module) {\n  /** @type {import(\"../semantic/types.js\").Expression[]} */\n  const expressions = []\n  /**\n   * Collects expressions recursively.\n   * @param {import(\"../semantic/types.js\").Expression} expression - Current expression.\n   * @returns {void}\n   */\n  const visitExpression = (expression) => {\n    expressions.push(expression)\n    if (expression.kind == \"UnaryExpression\") visitExpression(expression.operand)\n    else if (expression.kind == \"BinaryExpression\") {\n      visitExpression(expression.left)\n      visitExpression(expression.right)\n    } else if (expression.kind == \"CallExpression\") expression.arguments.forEach(visitExpression)\n  }\n  /**\n   * Collects expressions from a semantic block.\n   * @param {import(\"../semantic/types.js\").Block} block - Current block.\n   * @returns {void}\n   */\n  const visitBlock = (block) => block.statements.forEach((statement) => {\n    if (statement.kind == \"LocalDeclaration\") visitExpression(statement.initializer)\n    else if (statement.kind == \"AssignmentStatement\" || statement.kind == \"PrintStatement\" || statement.kind == \"ReturnStatement\") {\n      visitExpression(statement.expression)\n    } else {\n      visitExpression(statement.condition)\n      visitBlock(statement.consequent)\n      if (statement.alternate) visitBlock(statement.alternate)\n    }\n  })\n\n  module.functions.forEach((declaration) => visitBlock(declaration.body))\n  visitBlock(module.entryPoint.body)\n  for (const expression of expressions) {\n    const arithmetic = expression.kind == \"UnaryExpression\" && expression.operation == \"IntegerNegate\" ||\n      expression.kind == \"BinaryExpression\" && [\"IntegerAdd\", \"IntegerSubtract\", \"IntegerMultiply\"].includes(expression.operation)\n\n    if (arithmetic != checkedArithmetic.has(expression)) {\n      return unsupportedSyntax(\"csharp\", arithmetic ? \"integer arithmetic without exact checked wrapper\" : \"checked non-integer expression\",\n        expression.location)\n    }\n  }\n}\n\n/**\n * Parses the strict Task 017 C# profile.\n * @param {{filename: string, source: string}} input - Parser input.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parseCSharp({filename, source}) {\n  if (!hasOnlyUnicodeScalars(source)) {\n    const invalidOffset = firstLoneSurrogateOffset(source)\n\n    throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"csharp\",\n      location: locationFromOffsets(filename, source, invalidOffset, invalidOffset + 1),\n      message: \"C# source contains an invalid lone UTF-16 surrogate.\"})\n  }\n  let tree\n\n  try {\n    tree = parser.parse(source)\n  } catch (error) {\n    return parseFailure(\"csharp\", error)\n  }\n  const root = tree.rootNode\n\n  validateParserTree(root, filename, source)\n  if (root.type != \"compilation_unit\") throw new Error(`Tree-sitter returned C# root '${root.type}'.`)\n  const children = semanticChildren(root)\n  const location = moduleLocation(filename, source)\n\n  if (children.length != 3 || children[0].type != \"preproc_nullable\" ||\n    !/^#nullable enable(?:(?:\\r\\n|\\n|\\r))+$/u.test(children[0].text) ||\n    children[1].type != \"file_scoped_namespace_declaration\" || children[2].type != \"class_declaration\") {\n    return unsupportedSyntax(\"csharp\", \"compilation-unit scaffolding\", location)\n  }\n  const namespaceName = requiredField(children[1], \"name\", filename, source)\n\n  if (namespaceName.text != \"Semantifold.Generated\") {\n    return unsupportedSyntax(\"csharp\", \"namespace scaffolding\", nodeLocation(children[1], filename, source))\n  }\n  const classNode = children[2]\n  const className = requiredField(classNode, \"name\", filename, source)\n  const classBody = requiredField(classNode, \"body\", filename, source)\n  const classChildren = semanticChildren(classNode)\n  const classModifiers = classChildren.filter((child) => child.type == \"modifier\")\n\n  if (classChildren.length != 4 || className.text != \"Program\" ||\n    classModifiers.map(({text}) => text).join(\" \") != \"internal static\") {\n    return unsupportedSyntax(\"csharp\", \"Program class scaffolding\", nodeLocation(classNode, filename, source))\n  }\n  const members = semanticChildren(classBody)\n\n  if (members.length < 2 || members.some((member) => member.type != \"method_declaration\")) {\n    return unsupportedSyntax(\"csharp\", \"Program members\", nodeLocation(classBody, filename, source))\n  }\n  const mainNodes = members.filter((member) => member.childForFieldName(\"name\")?.text == \"Main\")\n\n  if (mainNodes.length != 1 || members.at(-1)?.id != mainNodes[0].id) {\n    return unsupportedSyntax(\"csharp\", \"Main ordering\", nodeLocation(classBody, filename, source))\n  }\n  const comments = root.descendantsOfType(\"comment\")\n  const context = {comments, usedImmutableMarkers: new Set()}\n  const module = {\n    entryPoint: convertMain(mainNodes[0], context, filename, source),\n    functions: members.slice(0, -1).map((member) => convertFunction(member, context, filename, source)),\n    kind: /** @type {const} */ (\"Module\"),\n    location\n  }\n  const unusedMarker = comments.find((comment) => comment.text == immutableMarker && !context.usedImmutableMarkers.has(comment))\n\n  if (unusedMarker) return unsupportedSyntax(\"csharp\", \"unattached immutable marker\", nodeLocation(unusedMarker, filename, source))\n  validateParsedModule(module, \"csharp\")\n  validateCheckedArithmetic(module)\n  return module\n}\n"]}