semantifold 0.1.0

package/build/src/frontends/php.js

@@ -0,0 +1,523 @@
+// @ts-check
+import PhpParser from "php-parser";
+import { parse as parseComment } from "comment-parser";
+import { missingType, parseFailure, unsupportedSyntax } from "../diagnostic.js";
+import { locationFromOffsets, moduleLocation } from "../semantic/location.js";
+import { withAdaptedOperation } from "../semantic/operators.js";
+import { withParserRanges } from "../semantic/provenance.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { requireSourceScalarType } from "./scalars.js";
+const parser = new PhpParser.Engine({
+    ast: { withPositions: true },
+    parser: { extractDoc: true, suppressErrors: false }
+});
+/** @type {string | undefined} */
+let cachedTokenSource;
+/** @type {{end: number, start: number, text: string}[]} */
+let cachedTokenRanges = [];
+const phpBinaryOperations = new Map([
+    ["+", "PhpAdd"],
+    ["-", "Subtract"],
+    ["*", "Multiply"],
+    ["&&", "And"],
+    ["||", "Or"],
+    ["===", "Equal"],
+    ["!==", "NotEqual"],
+    ["<", "LessThan"],
+    ["<=", "LessThanOrEqual"],
+    [">", "GreaterThan"],
+    [">=", "GreaterThanOrEqual"],
+    [".", "StringConcat"]
+]);
+/**
+ * Returns a normalized PHP node location.
+ * @param {import("php-parser").Node} node - PHP parser node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Source location.
+ */
+function nodeLocation(node, filename, source) {
+    if (!node.loc)
+        throw new Error(`PHP parser omitted source location for ${node.kind}.`);
+    return locationFromOffsets(filename, source, node.loc.start.offset, node.loc.end.offset);
+}
+/**
+ * Locates a comment-parser token inside a PHP parser-owned doc comment.
+ * @param {import("php-parser").CommentBlock} comment - PHP doc comment.
+ * @param {import("comment-parser").Spec} tag - Parsed doc tag.
+ * @param {"name" | "type"} field - Token field.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Exact token location.
+ */
+function commentTagLocation(comment, tag, field, filename, source) {
+    const line = tag.source[0];
+    if (!comment.loc || !line)
+        throw new Error(`Comment parser omitted the @${tag.tag} source token.`);
+    let lineStart = comment.loc.start.offset;
+    for (let lineNumber = 0; lineNumber < line.number; lineNumber++) {
+        while (lineStart < source.length && source[lineStart] != "\r" && source[lineStart] != "\n")
+            lineStart++;
+        if (source[lineStart] == "\r" && source[lineStart + 1] == "\n")
+            lineStart += 2;
+        else
+            lineStart++;
+    }
+    const orderedFields = ["start", "delimiter", "postDelimiter", "tag", "postTag", "name", "postName", "type"];
+    const fieldIndex = orderedFields.indexOf(field);
+    const start = lineStart + orderedFields.slice(0, fieldIndex).reduce((length, key) => length + line.tokens[ /** @type {keyof typeof line.tokens} */(key)].length, 0);
+    const value = line.tokens[field];
+    return locationFromOffsets(filename, source, start, start + value.length);
+}
+/**
+ * Finds one parser token between parser-owned node boundaries.
+ * @param {string} tokenText - Exact token text.
+ * @param {number} startOffset - Inclusive search boundary.
+ * @param {number} endOffset - Exclusive search boundary.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Token location.
+ */
+function tokenLocation(tokenText, startOffset, endOffset, filename, source) {
+    if (cachedTokenSource != source) {
+        let offset = 0;
+        cachedTokenRanges = parser.tokenGetAll(source).map((token) => {
+            const text = typeof token == "string" ? token : token[1];
+            const range = { end: offset + text.length, start: offset, text };
+            offset = range.end;
+            return range;
+        });
+        cachedTokenSource = source;
+    }
+    const token = cachedTokenRanges.find((candidate) => candidate.text == tokenText && candidate.start >= startOffset &&
+        candidate.end <= endOffset);
+    if (token)
+        return locationFromOffsets(filename, source, token.start, token.end);
+    throw new Error(`PHP parser omitted token '${tokenText}' between ${startOffset} and ${endOffset}.`);
+}
+/**
+ * Converts a supported PHP expression.
+ * @param {import("php-parser").Expression} node - PHP expression.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Expression} Semantic expression.
+ */
+function convertExpression(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.kind == "variable") {
+        const variable = /** @type {import("php-parser").Variable} */ (node);
+        if (typeof variable.name != "string")
+            return unsupportedSyntax("php", "dynamic variable", location);
+        return withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location, name: variable.name }, { name: location });
+    }
+    if (node.kind == "number") {
+        const literal = /** @type {import("php-parser").Number} */ (node);
+        const value = Number(literal.value);
+        if (!Number.isSafeInteger(value))
+            return unsupportedSyntax("php", "non-safe integer literal", location);
+        return withParserRanges({ kind: /** @type {const} */ ("IntegerLiteral"), location, value }, { literal: location });
+    }
+    if (node.kind == "boolean") {
+        const literal = /** @type {import("php-parser").Boolean} */ (node);
+        if (typeof literal.value != "boolean")
+            return unsupportedSyntax("php", "invalid boolean literal value", location);
+        return withParserRanges({ kind: /** @type {const} */ ("BooleanLiteral"), location, value: literal.value }, { literal: location });
+    }
+    if (node.kind == "string") {
+        const literal = /** @type {import("php-parser").String} */ (node);
+        if (typeof literal.raw == "string" && literal.raw.startsWith("<<<")) {
+            const detail = literal.raw.startsWith("<<<'") ? "nowdoc string" : "heredoc string";
+            return unsupportedSyntax("php", detail, location);
+        }
+        if (typeof literal.raw == "string" && ["b\"", "B\"", "b'", "B'"].some((prefix) => literal.raw.startsWith(prefix))) {
+            return unsupportedSyntax("php", "binary string literal", location);
+        }
+        if (typeof literal.value != "string" || !hasOnlyUnicodeScalars(literal.value)) {
+            return unsupportedSyntax("php", "invalid Unicode string literal", location);
+        }
+        return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: literal.value }, { literal: location });
+    }
+    if (node.kind == "encapsed") {
+        const literal = /** @type {import("php-parser").Encapsed} */ (node);
+        const detail = literal.type == "string" ? "interpolated string" : `${literal.type} string`;
+        return unsupportedSyntax("php", detail, location);
+    }
+    if (node.kind == "nowdoc")
+        return unsupportedSyntax("php", "nowdoc string", location);
+    if (node.kind == "unary") {
+        const unary = /** @type {import("php-parser").Unary} */ (node);
+        if (!["!", "-"].includes(unary.type))
+            return unsupportedSyntax("php", `unary ${unary.type}`, location);
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand: convertExpression(unary.what, filename, source)
+        }, {
+            operator: tokenLocation(unary.type, unary.loc?.start.offset ?? 0, unary.what.loc?.start.offset ?? unary.loc?.end.offset ?? source.length, filename, source)
+        }), unary.type == "!" ? "Not" : "Negate");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.kind == "bin") {
+        const binary = /** @type {import("php-parser").Bin} */ (node);
+        if (["==", "!="].includes(binary.type))
+            return unsupportedSyntax("php", `coercive equality ${binary.type}`, location);
+        if (["and", "or"].includes(binary.type))
+            return unsupportedSyntax("php", `precedence-sensitive boolean ${binary.type}`, location);
+        if (!phpBinaryOperations.has(binary.type))
+            return unsupportedSyntax("php", `binary ${binary.type}`, location);
+        const semantic = withAdaptedOperation({
+            kind: /** @type {const} */ ("BinaryExpression"),
+            left: convertExpression(binary.left, filename, source),
+            location,
+            right: convertExpression(binary.right, filename, source)
+        }, /** @type {import("../semantic/operators.js").AdaptedOperation} */ (phpBinaryOperations.get(binary.type)));
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(withParserRanges(semantic, {
+            operator: tokenLocation(binary.type, binary.left.loc?.end.offset ?? 0, binary.right.loc?.start.offset ?? source.length, filename, source)
+        })));
+    }
+    if (node.kind == "call") {
+        const call = /** @type {import("php-parser").Call} */ (node);
+        if (call.what.kind != "name" && call.what.kind != "identifier") {
+            return unsupportedSyntax("php", "dynamic call", location);
+        }
+        const callee = /** @type {import("php-parser").Name | import("php-parser").Identifier} */ (call.what).name;
+        return withParserRanges({
+            arguments: call.arguments.map((argument) => convertExpression(argument, filename, source)),
+            callee,
+            kind: "CallExpression",
+            location
+        }, { callee: nodeLocation(call.what, filename, source) });
+    }
+    return unsupportedSyntax("php", node.kind, location);
+}
+/**
+ * Converts one explicit PHP return.
+ * @param {import("php-parser").Node} node - PHP node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").ReturnStatement} Semantic return.
+ */
+function convertReturn(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.kind != "return")
+        return unsupportedSyntax("php", node.kind, location);
+    const returnNode = /** @type {import("php-parser").Return} */ (node);
+    if (!returnNode.expr)
+        return unsupportedSyntax("php", "empty return", location);
+    return { expression: convertExpression(returnNode.expr, filename, source), kind: "ReturnStatement", location };
+}
+/**
+ * Reads one exact PHP local `@var` carrier and immutability marker.
+ * @param {import("php-parser").Node} node - Assignment-owning statement.
+ * @param {string} name - Local name.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {{immutable: boolean, type: import("../semantic/types.js").TypeReference} | undefined} Metadata when present.
+ */
+function localMetadata(node, name, filename, source) {
+    const comments = node.leadingComments ?? [];
+    const comment = comments.at(-1);
+    if (!comment || comment.kind != "commentblock" || !comment.loc || !node.loc)
+        return undefined;
+    const gap = source.slice(comment.loc.end.offset, node.loc.start.offset);
+    if (!/^\s*$/u.test(gap) || (gap.match(/\n/gu)?.length ?? 0) > 1)
+        return undefined;
+    const block = parseComment(comment.value)[0];
+    const tags = block?.tags ?? [];
+    const variables = tags.filter((tag) => tag.tag == "var");
+    const immutable = tags.filter((tag) => tag.tag == "semantifold-immutable");
+    const location = nodeLocation(node, filename, source);
+    if (variables.length == 0 && immutable.length == 0)
+        return undefined;
+    const exactVariable = variables.length == 1 && variables[0].type == "" && variables[0].description == `$${name}`;
+    const exactImmutable = immutable.length <= 1 && immutable.every((tag) => tag.name == "" && tag.type == "" && tag.description == "");
+    const knownTags = tags.every((tag) => tag.tag == "var" || tag.tag == "semantifold-immutable");
+    if (!exactVariable || !exactImmutable || !knownTags) {
+        return unsupportedSyntax("php", "malformed local type metadata", location);
+    }
+    return {
+        immutable: immutable.length == 1,
+        type: requireSourceScalarType("php", variables[0].name, `Local '${name}'`, location, commentTagLocation(comment, variables[0], "name", filename, source))
+    };
+}
+/**
+ * Converts one PHP local declaration or assignment.
+ * @param {import("php-parser").Node} node - PHP statement.
+ * @param {Set<string>} visible - Names visible during adaptation.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").LocalStatement} Semantic local statement.
+ */
+function convertLocalStatement(node, visible, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.kind != "expressionstatement")
+        return unsupportedSyntax("php", node.kind, location);
+    const expression = /** @type {import("php-parser").ExpressionStatement} */ (node).expression;
+    if (expression.kind != "assign")
+        return unsupportedSyntax("php", expression.kind, nodeLocation(expression, filename, source));
+    const assignment = /** @type {import("php-parser").Assign} */ (expression);
+    if (assignment.operator != "=")
+        return unsupportedSyntax("php", `assignment ${assignment.operator}`, location);
+    if (assignment.left.kind != "variable")
+        return unsupportedSyntax("php", assignment.left.kind, nodeLocation(assignment.left, filename, source));
+    const variable = /** @type {import("php-parser").Variable} */ (assignment.left);
+    const targetLocation = nodeLocation(variable, filename, source);
+    if (typeof variable.name != "string" || variable.curly)
+        return unsupportedSyntax("php", "dynamic variable", targetLocation);
+    const metadata = localMetadata(node, variable.name, filename, source);
+    if (metadata) {
+        visible.add(variable.name);
+        return withParserRanges({
+            initializer: convertExpression(assignment.right, filename, source),
+            kind: "LocalDeclaration",
+            location,
+            mutable: !metadata.immutable,
+            name: variable.name,
+            type: metadata.type
+        }, {
+            name: targetLocation,
+            operator: tokenLocation("=", assignment.left.loc?.end.offset ?? 0, assignment.right.loc?.start.offset ?? source.length, filename, source)
+        });
+    }
+    if (!visible.has(variable.name))
+        return missingType("php", `Local '${variable.name}'`, location);
+    const target = withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: targetLocation, name: variable.name }, {
+        name: targetLocation
+    });
+    return withParserRanges({
+        expression: convertExpression(assignment.right, filename, source),
+        kind: "AssignmentStatement",
+        location,
+        target
+    }, {
+        operator: tokenLocation("=", assignment.left.loc?.end.offset ?? 0, assignment.right.loc?.start.offset ?? source.length, filename, source)
+    });
+}
+/**
+ * Converts one exhaustive PHP statement.
+ * @param {import("php-parser").Node} node - PHP statement.
+ * @param {Set<string>} visible - Names visible during adaptation.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Statement} Semantic statement.
+ */
+function convertStatement(node, visible, filename, source) {
+    if (node.kind == "return")
+        return convertReturn(node, filename, source);
+    if (node.kind == "if")
+        return convertIf(/** @type {import("php-parser").If} */ (node), visible, filename, source);
+    if (node.kind == "echo")
+        return convertPrint(/** @type {import("php-parser").Echo} */ (node), filename, source);
+    if (node.kind == "expressionstatement")
+        return convertLocalStatement(node, visible, filename, source);
+    return unsupportedSyntax("php", node.kind, nodeLocation(node, filename, source));
+}
+/**
+ * Converts an ordered PHP block with its own adaptation scope.
+ * @param {import("php-parser").Block} node - PHP parser block.
+ * @param {Set<string>} visible - Names visible on block entry.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Block} Semantic block.
+ */
+function convertBlock(node, visible, filename, source) {
+    return {
+        kind: "Block",
+        location: nodeLocation(node, filename, source),
+        statements: node.children.map((statement) => convertStatement(statement, visible, filename, source))
+    };
+}
+/**
+ * Requires an exact PHP scalar declaration type.
+ * @param {import("php-parser").Node | null} sourceType - PHP type node.
+ * @param {string} subject - Typed subject.
+ * @param {import("../semantic/types.js").SourceLocation} location - Source location.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").TypeReference} Semantic type.
+ */
+function convertType(sourceType, subject, location, filename, source) {
+    if (!sourceType)
+        return requireSourceScalarType("php", undefined, subject, location);
+    if (sourceType.kind != "typereference" && sourceType.kind != "name" && sourceType.kind != "identifier") {
+        return unsupportedSyntax("php", "unsupported scalar type", nodeLocation(sourceType, filename, source));
+    }
+    const typeName = /** @type {import("php-parser").TypeReference | import("php-parser").Name | import("php-parser").Identifier} */ (sourceType).name;
+    return requireSourceScalarType("php", typeName, subject, location, nodeLocation(sourceType, filename, source));
+}
+/**
+ * Converts a PHP function.
+ * @param {import("php-parser").Function} node - PHP function node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+ */
+function convertFunction(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    const name = typeof node.name == "string" ? node.name : node.name.name;
+    if (!node.body) {
+        return unsupportedSyntax("php", "function body", location);
+    }
+    const parameters = node.arguments.map((parameter) => {
+        const parameterLocation = nodeLocation(parameter, filename, source);
+        const parameterName = typeof parameter.name == "string" ? parameter.name : parameter.name.name;
+        if (parameter.nullable)
+            return unsupportedSyntax("php", "unsupported scalar type", parameterLocation);
+        const parameterNode = typeof parameter.name == "string" ? parameter : parameter.name;
+        const semanticParameter = {
+            kind: /** @type {const} */ ("Parameter"),
+            location: parameterLocation,
+            name: parameterName,
+            type: convertType(parameter.type, `Parameter '${parameterName}'`, parameterLocation, filename, source)
+        };
+        return withParserRanges(semanticParameter, { name: nodeLocation(parameterNode, filename, source) });
+    });
+    if (node.nullable)
+        return unsupportedSyntax("php", "unsupported scalar type", location);
+    const visible = new Set(parameters.map((parameter) => parameter.name));
+    const body = convertBlock(node.body, visible, filename, source);
+    const nameNode = typeof node.name == "string" ? node : node.name;
+    return withParserRanges({
+        body,
+        kind: "FunctionDeclaration",
+        location,
+        name,
+        parameters,
+        returnType: convertType(node.type, `Function '${name}' return`, location, filename, source)
+    }, { name: nodeLocation(nameNode, filename, source) });
+}
+/**
+ * Converts the existing PHP if/else terminal with restricted branch prefixes.
+ * @param {import("php-parser").If} node - PHP if node.
+ * @param {Set<string>} visible - Enclosing visible names.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").IfStatement} Semantic branch.
+ */
+function convertIf(node, visible, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.shortForm)
+        return unsupportedSyntax("php", "alternative if syntax", location);
+    if (node.body.kind != "block")
+        return unsupportedSyntax("php", "if without block consequent", location);
+    const consequentVisible = new Set(visible);
+    let alternate;
+    if (node.alternate) {
+        const alternateVisible = new Set(visible);
+        if (node.alternate.kind == "block") {
+            alternate = convertBlock(/** @type {import("php-parser").Block} */ (node.alternate), alternateVisible, filename, source);
+        }
+        else if (node.alternate.kind == "if") {
+            const nested = /** @type {import("php-parser").If} */ (node.alternate);
+            alternate = {
+                kind: /** @type {const} */ ("Block"),
+                location: nodeLocation(nested, filename, source),
+                statements: [convertIf(nested, alternateVisible, filename, source)]
+            };
+        }
+        else
+            return unsupportedSyntax("php", `if alternate ${node.alternate.kind}`, nodeLocation(node.alternate, filename, source));
+    }
+    return {
+        ...(alternate ? { alternate } : {}),
+        condition: convertExpression(node.test, filename, source),
+        consequent: convertBlock(node.body, consequentVisible, filename, source),
+        kind: "IfStatement",
+        location
+    };
+}
+/**
+ * Converts a PHP echo entry point.
+ * @param {import("php-parser").Echo} node - PHP echo node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").PrintStatement} Print statement.
+ */
+function convertPrint(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.expressions.length != 2 || node.expressions[1].kind != "name" ||
+        /** @type {import("php-parser").Name} */ (node.expressions[1]).name != "PHP_EOL") {
+        return unsupportedSyntax("php", "echo without one expression and PHP_EOL", location);
+    }
+    return { expression: convertExpression(node.expressions[0], filename, source), kind: "PrintStatement", location };
+}
+/**
+ * Parses PHP into the shared semantic module.
+ * @param {object} input - Parser input.
+ * @param {string} input.filename - Source filename.
+ * @param {string} input.source - Source text.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parsePhp({ filename, source }) {
+    const program = parsePhpProgram(filename, source);
+    validateDeclareNodes(program.children, filename, source);
+    const functions = program.children.filter((node) => node.kind == "function")
+        .map((node) => convertFunction(/** @type {import("php-parser").Function} */ (node), filename, source));
+    const executableNodes = program.children.filter((node) => node.kind != "function" && node.kind != "declare" && node.kind != "noop");
+    const location = moduleLocation(filename, source);
+    if (functions.length == 0)
+        return unsupportedSyntax("php", "module without a function", location);
+    const first = executableNodes[0];
+    const last = executableNodes.at(-1) ?? first;
+    const entryLocation = first
+        ? locationFromOffsets(filename, source, first.loc?.start.offset ?? 0, last?.loc?.end.offset ?? source.length)
+        : location;
+    const entryVisible = new Set();
+    const entryBlock = {
+        kind: /** @type {const} */ ("Block"),
+        location: entryLocation,
+        statements: executableNodes.map((node) => convertStatement(node, entryVisible, filename, source))
+    };
+    return {
+        entryPoint: {
+            body: entryBlock,
+            kind: "EntryPoint",
+            location: entryLocation
+        },
+        functions,
+        kind: "Module",
+        location
+    };
+}
+/**
+ * Accepts only an optional single `declare(strict_types=1)` directive.
+ * @param {import("php-parser").Node[]} nodes - Top-level PHP nodes.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {void}
+ */
+function validateDeclareNodes(nodes, filename, source) {
+    const declarations = nodes.filter((node) => node.kind == "declare");
+    if (declarations.length > 1) {
+        unsupportedSyntax("php", "multiple declare directives", nodeLocation(declarations[1], filename, source));
+    }
+    for (const declarationNode of declarations) {
+        const declaration = /** @type {import("php-parser").Declare} */ (declarationNode);
+        const directive = declaration.directives[0];
+        const key = directive?.key;
+        const value = directive?.value;
+        const numericValue = value && typeof value == "object" && value.kind == "number"
+            ? /** @type {import("php-parser").Number} */ (value)
+            : undefined;
+        const valueIsOne = numericValue?.loc && source.slice(numericValue.loc.start.offset, numericValue.loc.end.offset) == "1";
+        const valid = declaration.mode == "none" && declaration.children.length == 0 && declaration.directives.length == 1 &&
+            key.kind == "identifier" && key.name == "strict_types" && valueIsOne;
+        if (!valid)
+            unsupportedSyntax("php", "declare other than strict_types=1", nodeLocation(declaration, filename, source));
+    }
+}
+/**
+ * Invokes php-parser and normalizes syntax failures.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Source text.
+ * @returns {import("php-parser").Program} PHP program.
+ */
+function parsePhpProgram(filename, source) {
+    try {
+        return parser.parseCode(source, filename);
+    }
+    catch (error) {
+        return parseFailure("php", error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"php.js","sourceRoot":"","sources":["../../../src/frontends/php.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport PhpParser from \"php-parser\"\nimport {parse as parseComment} from \"comment-parser\"\nimport {missingType, parseFailure, unsupportedSyntax} from \"../diagnostic.js\"\nimport {locationFromOffsets, moduleLocation} from \"../semantic/location.js\"\nimport {withAdaptedOperation} from \"../semantic/operators.js\"\nimport {withParserRanges} from \"../semantic/provenance.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {requireSourceScalarType} from \"./scalars.js\"\nconst parser = new PhpParser.Engine({\n  ast: {withPositions: true},\n  parser: {extractDoc: true, suppressErrors: false}\n})\n/** @type {string | undefined} */\nlet cachedTokenSource\n/** @type {{end: number, start: number, text: string}[]} */\nlet cachedTokenRanges = []\nconst phpBinaryOperations = new Map([\n  [\"+\", \"PhpAdd\"],\n  [\"-\", \"Subtract\"],\n  [\"*\", \"Multiply\"],\n  [\"&&\", \"And\"],\n  [\"||\", \"Or\"],\n  [\"===\", \"Equal\"],\n  [\"!==\", \"NotEqual\"],\n  [\"<\", \"LessThan\"],\n  [\"<=\", \"LessThanOrEqual\"],\n  [\">\", \"GreaterThan\"],\n  [\">=\", \"GreaterThanOrEqual\"],\n  [\".\", \"StringConcat\"]\n])\n\n/**\n * Returns a normalized PHP node location.\n * @param {import(\"php-parser\").Node} node - PHP parser node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Source location.\n */\nfunction nodeLocation(node, filename, source) {\n  if (!node.loc) throw new Error(`PHP parser omitted source location for ${node.kind}.`)\n\n  return locationFromOffsets(filename, source, node.loc.start.offset, node.loc.end.offset)\n}\n\n/**\n * Locates a comment-parser token inside a PHP parser-owned doc comment.\n * @param {import(\"php-parser\").CommentBlock} comment - PHP doc comment.\n * @param {import(\"comment-parser\").Spec} tag - Parsed doc tag.\n * @param {\"name\" | \"type\"} field - Token field.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Exact token location.\n */\nfunction commentTagLocation(comment, tag, field, filename, source) {\n  const line = tag.source[0]\n\n  if (!comment.loc || !line) throw new Error(`Comment parser omitted the @${tag.tag} source token.`)\n\n  let lineStart = comment.loc.start.offset\n\n  for (let lineNumber = 0; lineNumber < line.number; lineNumber++) {\n    while (lineStart < source.length && source[lineStart] != \"\\r\" && source[lineStart] != \"\\n\") lineStart++\n    if (source[lineStart] == \"\\r\" && source[lineStart + 1] == \"\\n\") lineStart += 2\n    else lineStart++\n  }\n\n  const orderedFields = [\"start\", \"delimiter\", \"postDelimiter\", \"tag\", \"postTag\", \"name\", \"postName\", \"type\"]\n  const fieldIndex = orderedFields.indexOf(field)\n  const start = lineStart + orderedFields.slice(0, fieldIndex).reduce((length, key) =>\n    length + line.tokens[/** @type {keyof typeof line.tokens} */ (key)].length, 0)\n  const value = line.tokens[field]\n\n  return locationFromOffsets(filename, source, start, start + value.length)\n}\n\n/**\n * Finds one parser token between parser-owned node boundaries.\n * @param {string} tokenText - Exact token text.\n * @param {number} startOffset - Inclusive search boundary.\n * @param {number} endOffset - Exclusive search boundary.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Token location.\n */\nfunction tokenLocation(tokenText, startOffset, endOffset, filename, source) {\n  if (cachedTokenSource != source) {\n    let offset = 0\n\n    cachedTokenRanges = parser.tokenGetAll(source).map((token) => {\n      const text = typeof token == \"string\" ? token : token[1]\n      const range = {end: offset + text.length, start: offset, text}\n\n      offset = range.end\n\n      return range\n    })\n    cachedTokenSource = source\n  }\n\n  const token = cachedTokenRanges.find((candidate) => candidate.text == tokenText && candidate.start >= startOffset &&\n    candidate.end <= endOffset)\n\n  if (token) return locationFromOffsets(filename, source, token.start, token.end)\n\n  throw new Error(`PHP parser omitted token '${tokenText}' between ${startOffset} and ${endOffset}.`)\n}\n\n/**\n * Converts a supported PHP expression.\n * @param {import(\"php-parser\").Expression} node - PHP expression.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n */\nfunction convertExpression(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.kind == \"variable\") {\n    const variable = /** @type {import(\"php-parser\").Variable} */ (node)\n\n    if (typeof variable.name != \"string\") return unsupportedSyntax(\"php\", \"dynamic variable\", location)\n\n    return withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location, name: variable.name}, {name: location})\n  }\n\n  if (node.kind == \"number\") {\n    const literal = /** @type {import(\"php-parser\").Number} */ (node)\n    const value = Number(literal.value)\n\n    if (!Number.isSafeInteger(value)) return unsupportedSyntax(\"php\", \"non-safe integer literal\", location)\n\n    return withParserRanges({kind: /** @type {const} */ (\"IntegerLiteral\"), location, value}, {literal: location})\n  }\n\n  if (node.kind == \"boolean\") {\n    const literal = /** @type {import(\"php-parser\").Boolean} */ (node)\n\n    if (typeof literal.value != \"boolean\") return unsupportedSyntax(\"php\", \"invalid boolean literal value\", location)\n\n    return withParserRanges({kind: /** @type {const} */ (\"BooleanLiteral\"), location, value: literal.value}, {literal: location})\n  }\n\n  if (node.kind == \"string\") {\n    const literal = /** @type {import(\"php-parser\").String} */ (node)\n\n    if (typeof literal.raw == \"string\" && literal.raw.startsWith(\"<<<\")) {\n      const detail = literal.raw.startsWith(\"<<<'\") ? \"nowdoc string\" : \"heredoc string\"\n\n      return unsupportedSyntax(\"php\", detail, location)\n    }\n    if (typeof literal.raw == \"string\" && [\"b\\\"\", \"B\\\"\", \"b'\", \"B'\"].some((prefix) => literal.raw.startsWith(prefix))) {\n      return unsupportedSyntax(\"php\", \"binary string literal\", location)\n    }\n    if (typeof literal.value != \"string\" || !hasOnlyUnicodeScalars(literal.value)) {\n      return unsupportedSyntax(\"php\", \"invalid Unicode string literal\", location)\n    }\n\n    return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: literal.value}, {literal: location})\n  }\n\n  if (node.kind == \"encapsed\") {\n    const literal = /** @type {import(\"php-parser\").Encapsed} */ (node)\n    const detail = literal.type == \"string\" ? \"interpolated string\" : `${literal.type} string`\n\n    return unsupportedSyntax(\"php\", detail, location)\n  }\n\n  if (node.kind == \"nowdoc\") return unsupportedSyntax(\"php\", \"nowdoc string\", location)\n\n  if (node.kind == \"unary\") {\n    const unary = /** @type {import(\"php-parser\").Unary} */ (node)\n\n    if (![\"!\", \"-\"].includes(unary.type)) return unsupportedSyntax(\"php\", `unary ${unary.type}`, location)\n\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand: convertExpression(unary.what, filename, source)\n    }, {\n      operator: tokenLocation(unary.type, unary.loc?.start.offset ?? 0, unary.what.loc?.start.offset ?? unary.loc?.end.offset ?? source.length, filename, source)\n    }), unary.type == \"!\" ? \"Not\" : \"Negate\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node.kind == \"bin\") {\n    const binary = /** @type {import(\"php-parser\").Bin} */ (node)\n    if ([\"==\", \"!=\"].includes(binary.type)) return unsupportedSyntax(\"php\", `coercive equality ${binary.type}`, location)\n    if ([\"and\", \"or\"].includes(binary.type)) return unsupportedSyntax(\"php\", `precedence-sensitive boolean ${binary.type}`, location)\n    if (!phpBinaryOperations.has(binary.type)) return unsupportedSyntax(\"php\", `binary ${binary.type}`, location)\n\n    const semantic = withAdaptedOperation({\n      kind: /** @type {const} */ (\"BinaryExpression\"),\n      left: convertExpression(binary.left, filename, source),\n      location,\n      right: convertExpression(binary.right, filename, source)\n    }, /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (phpBinaryOperations.get(binary.type)))\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (withParserRanges(semantic, {\n      operator: tokenLocation(binary.type, binary.left.loc?.end.offset ?? 0, binary.right.loc?.start.offset ?? source.length, filename, source)\n    })))\n  }\n\n  if (node.kind == \"call\") {\n    const call = /** @type {import(\"php-parser\").Call} */ (node)\n\n    if (call.what.kind != \"name\" && call.what.kind != \"identifier\") {\n      return unsupportedSyntax(\"php\", \"dynamic call\", location)\n    }\n\n    const callee = /** @type {import(\"php-parser\").Name | import(\"php-parser\").Identifier} */ (call.what).name\n\n    return withParserRanges({\n      arguments: call.arguments.map((argument) => convertExpression(argument, filename, source)),\n      callee,\n      kind: \"CallExpression\",\n      location\n    }, {callee: nodeLocation(call.what, filename, source)})\n  }\n\n  return unsupportedSyntax(\"php\", node.kind, location)\n}\n\n/**\n * Converts one explicit PHP return.\n * @param {import(\"php-parser\").Node} node - PHP node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").ReturnStatement} Semantic return.\n */\nfunction convertReturn(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.kind != \"return\") return unsupportedSyntax(\"php\", node.kind, location)\n\n  const returnNode = /** @type {import(\"php-parser\").Return} */ (node)\n\n  if (!returnNode.expr) return unsupportedSyntax(\"php\", \"empty return\", location)\n\n  return {expression: convertExpression(returnNode.expr, filename, source), kind: \"ReturnStatement\", location}\n}\n\n/**\n * Reads one exact PHP local `@var` carrier and immutability marker.\n * @param {import(\"php-parser\").Node} node - Assignment-owning statement.\n * @param {string} name - Local name.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {{immutable: boolean, type: import(\"../semantic/types.js\").TypeReference} | undefined} Metadata when present.\n */\nfunction localMetadata(node, name, filename, source) {\n  const comments = node.leadingComments ?? []\n  const comment = comments.at(-1)\n\n  if (!comment || comment.kind != \"commentblock\" || !comment.loc || !node.loc) return undefined\n\n  const gap = source.slice(comment.loc.end.offset, node.loc.start.offset)\n\n  if (!/^\\s*$/u.test(gap) || (gap.match(/\\n/gu)?.length ?? 0) > 1) return undefined\n\n  const block = parseComment(comment.value)[0]\n  const tags = block?.tags ?? []\n  const variables = tags.filter((tag) => tag.tag == \"var\")\n  const immutable = tags.filter((tag) => tag.tag == \"semantifold-immutable\")\n  const location = nodeLocation(node, filename, source)\n\n  if (variables.length == 0 && immutable.length == 0) return undefined\n\n  const exactVariable = variables.length == 1 && variables[0].type == \"\" && variables[0].description == `$${name}`\n  const exactImmutable = immutable.length <= 1 && immutable.every((tag) => tag.name == \"\" && tag.type == \"\" && tag.description == \"\")\n  const knownTags = tags.every((tag) => tag.tag == \"var\" || tag.tag == \"semantifold-immutable\")\n\n  if (!exactVariable || !exactImmutable || !knownTags) {\n    return unsupportedSyntax(\"php\", \"malformed local type metadata\", location)\n  }\n\n  return {\n    immutable: immutable.length == 1,\n    type: requireSourceScalarType(\n      \"php\",\n      variables[0].name,\n      `Local '${name}'`,\n      location,\n      commentTagLocation(comment, variables[0], \"name\", filename, source)\n    )\n  }\n}\n\n/**\n * Converts one PHP local declaration or assignment.\n * @param {import(\"php-parser\").Node} node - PHP statement.\n * @param {Set<string>} visible - Names visible during adaptation.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").LocalStatement} Semantic local statement.\n */\nfunction convertLocalStatement(node, visible, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.kind != \"expressionstatement\") return unsupportedSyntax(\"php\", node.kind, location)\n\n  const expression = /** @type {import(\"php-parser\").ExpressionStatement} */ (node).expression\n\n  if (expression.kind != \"assign\") return unsupportedSyntax(\"php\", expression.kind, nodeLocation(expression, filename, source))\n\n  const assignment = /** @type {import(\"php-parser\").Assign} */ (expression)\n\n  if (assignment.operator != \"=\") return unsupportedSyntax(\"php\", `assignment ${assignment.operator}`, location)\n  if (assignment.left.kind != \"variable\") return unsupportedSyntax(\"php\", assignment.left.kind, nodeLocation(assignment.left, filename, source))\n\n  const variable = /** @type {import(\"php-parser\").Variable} */ (assignment.left)\n  const targetLocation = nodeLocation(variable, filename, source)\n\n  if (typeof variable.name != \"string\" || variable.curly) return unsupportedSyntax(\"php\", \"dynamic variable\", targetLocation)\n\n  const metadata = localMetadata(node, variable.name, filename, source)\n\n  if (metadata) {\n    visible.add(variable.name)\n    return withParserRanges({\n      initializer: convertExpression(assignment.right, filename, source),\n      kind: \"LocalDeclaration\",\n      location,\n      mutable: !metadata.immutable,\n      name: variable.name,\n      type: metadata.type\n    }, {\n      name: targetLocation,\n      operator: tokenLocation(\"=\", assignment.left.loc?.end.offset ?? 0, assignment.right.loc?.start.offset ?? source.length, filename, source)\n    })\n  }\n\n  if (!visible.has(variable.name)) return missingType(\"php\", `Local '${variable.name}'`, location)\n\n  const target = withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: targetLocation, name: variable.name}, {\n    name: targetLocation\n  })\n\n  return withParserRanges({\n    expression: convertExpression(assignment.right, filename, source),\n    kind: \"AssignmentStatement\",\n    location,\n    target\n  }, {\n    operator: tokenLocation(\"=\", assignment.left.loc?.end.offset ?? 0, assignment.right.loc?.start.offset ?? source.length, filename, source)\n  })\n}\n\n/**\n * Converts one exhaustive PHP statement.\n * @param {import(\"php-parser\").Node} node - PHP statement.\n * @param {Set<string>} visible - Names visible during adaptation.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Statement} Semantic statement.\n */\nfunction convertStatement(node, visible, filename, source) {\n  if (node.kind == \"return\") return convertReturn(node, filename, source)\n  if (node.kind == \"if\") return convertIf(/** @type {import(\"php-parser\").If} */ (node), visible, filename, source)\n  if (node.kind == \"echo\") return convertPrint(/** @type {import(\"php-parser\").Echo} */ (node), filename, source)\n  if (node.kind == \"expressionstatement\") return convertLocalStatement(node, visible, filename, source)\n\n  return unsupportedSyntax(\"php\", node.kind, nodeLocation(node, filename, source))\n}\n\n/**\n * Converts an ordered PHP block with its own adaptation scope.\n * @param {import(\"php-parser\").Block} node - PHP parser block.\n * @param {Set<string>} visible - Names visible on block entry.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n */\nfunction convertBlock(node, visible, filename, source) {\n  return {\n    kind: \"Block\",\n    location: nodeLocation(node, filename, source),\n    statements: node.children.map((statement) => convertStatement(statement, visible, filename, source))\n  }\n}\n\n/**\n * Requires an exact PHP scalar declaration type.\n * @param {import(\"php-parser\").Node | null} sourceType - PHP type node.\n * @param {string} subject - Typed subject.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Source location.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").TypeReference} Semantic type.\n */\nfunction convertType(sourceType, subject, location, filename, source) {\n  if (!sourceType) return requireSourceScalarType(\"php\", undefined, subject, location)\n  if (sourceType.kind != \"typereference\" && sourceType.kind != \"name\" && sourceType.kind != \"identifier\") {\n    return unsupportedSyntax(\"php\", \"unsupported scalar type\", nodeLocation(sourceType, filename, source))\n  }\n\n  const typeName = /** @type {import(\"php-parser\").TypeReference | import(\"php-parser\").Name | import(\"php-parser\").Identifier} */ (sourceType).name\n\n  return requireSourceScalarType(\"php\", typeName, subject, location, nodeLocation(sourceType, filename, source))\n}\n\n/**\n * Converts a PHP function.\n * @param {import(\"php-parser\").Function} node - PHP function node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n */\nfunction convertFunction(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n  const name = typeof node.name == \"string\" ? node.name : node.name.name\n\n  if (!node.body) {\n    return unsupportedSyntax(\"php\", \"function body\", location)\n  }\n\n  const parameters = node.arguments.map((parameter) => {\n    const parameterLocation = nodeLocation(parameter, filename, source)\n    const parameterName = typeof parameter.name == \"string\" ? parameter.name : parameter.name.name\n\n    if (parameter.nullable) return unsupportedSyntax(\"php\", \"unsupported scalar type\", parameterLocation)\n\n    const parameterNode = typeof parameter.name == \"string\" ? parameter : parameter.name\n    const semanticParameter = {\n      kind: /** @type {const} */ (\"Parameter\"),\n      location: parameterLocation,\n      name: parameterName,\n      type: convertType(parameter.type, `Parameter '${parameterName}'`, parameterLocation, filename, source)\n    }\n\n    return withParserRanges(semanticParameter, {name: nodeLocation(parameterNode, filename, source)})\n  })\n  if (node.nullable) return unsupportedSyntax(\"php\", \"unsupported scalar type\", location)\n  const visible = new Set(parameters.map((parameter) => parameter.name))\n  const body = convertBlock(node.body, visible, filename, source)\n\n  const nameNode = typeof node.name == \"string\" ? node : node.name\n\n  return withParserRanges({\n    body,\n    kind: \"FunctionDeclaration\",\n    location,\n    name,\n    parameters,\n    returnType: convertType(node.type, `Function '${name}' return`, location, filename, source)\n  }, {name: nodeLocation(nameNode, filename, source)})\n}\n\n/**\n * Converts the existing PHP if/else terminal with restricted branch prefixes.\n * @param {import(\"php-parser\").If} node - PHP if node.\n * @param {Set<string>} visible - Enclosing visible names.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").IfStatement} Semantic branch.\n */\nfunction convertIf(node, visible, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.shortForm) return unsupportedSyntax(\"php\", \"alternative if syntax\", location)\n  if (node.body.kind != \"block\") return unsupportedSyntax(\"php\", \"if without block consequent\", location)\n\n  const consequentVisible = new Set(visible)\n  let alternate\n\n  if (node.alternate) {\n    const alternateVisible = new Set(visible)\n\n    if (node.alternate.kind == \"block\") {\n      alternate = convertBlock(/** @type {import(\"php-parser\").Block} */ (node.alternate), alternateVisible, filename, source)\n    } else if (node.alternate.kind == \"if\") {\n      const nested = /** @type {import(\"php-parser\").If} */ (node.alternate)\n\n      alternate = {\n        kind: /** @type {const} */ (\"Block\"),\n        location: nodeLocation(nested, filename, source),\n        statements: [convertIf(nested, alternateVisible, filename, source)]\n      }\n    } else return unsupportedSyntax(\"php\", `if alternate ${node.alternate.kind}`, nodeLocation(node.alternate, filename, source))\n  }\n\n  return {\n    ...(alternate ? {alternate} : {}),\n    condition: convertExpression(node.test, filename, source),\n    consequent: convertBlock(node.body, consequentVisible, filename, source),\n    kind: \"IfStatement\",\n    location\n  }\n}\n\n/**\n * Converts a PHP echo entry point.\n * @param {import(\"php-parser\").Echo} node - PHP echo node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").PrintStatement} Print statement.\n */\nfunction convertPrint(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.expressions.length != 2 || node.expressions[1].kind != \"name\" ||\n    /** @type {import(\"php-parser\").Name} */ (node.expressions[1]).name != \"PHP_EOL\") {\n    return unsupportedSyntax(\"php\", \"echo without one expression and PHP_EOL\", location)\n  }\n\n  return {expression: convertExpression(node.expressions[0], filename, source), kind: \"PrintStatement\", location}\n}\n\n/**\n * Parses PHP into the shared semantic module.\n * @param {object} input - Parser input.\n * @param {string} input.filename - Source filename.\n * @param {string} input.source - Source text.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parsePhp({filename, source}) {\n  const program = parsePhpProgram(filename, source)\n  validateDeclareNodes(program.children, filename, source)\n  const functions = program.children.filter((node) => node.kind == \"function\")\n    .map((node) => convertFunction(/** @type {import(\"php-parser\").Function} */ (node), filename, source))\n  const executableNodes = program.children.filter((node) => node.kind != \"function\" && node.kind != \"declare\" && node.kind != \"noop\")\n  const location = moduleLocation(filename, source)\n\n  if (functions.length == 0) return unsupportedSyntax(\"php\", \"module without a function\", location)\n  const first = executableNodes[0]\n  const last = executableNodes.at(-1) ?? first\n  const entryLocation = first\n    ? locationFromOffsets(filename, source, first.loc?.start.offset ?? 0, last?.loc?.end.offset ?? source.length)\n    : location\n  const entryVisible = new Set()\n  const entryBlock = {\n    kind: /** @type {const} */ (\"Block\"),\n    location: entryLocation,\n    statements: executableNodes.map((node) => convertStatement(node, entryVisible, filename, source))\n  }\n\n  return {\n    entryPoint: {\n      body: entryBlock,\n      kind: \"EntryPoint\",\n      location: entryLocation\n    },\n    functions,\n    kind: \"Module\",\n    location\n  }\n}\n\n/**\n * Accepts only an optional single `declare(strict_types=1)` directive.\n * @param {import(\"php-parser\").Node[]} nodes - Top-level PHP nodes.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {void}\n */\nfunction validateDeclareNodes(nodes, filename, source) {\n  const declarations = nodes.filter((node) => node.kind == \"declare\")\n\n  if (declarations.length > 1) {\n    unsupportedSyntax(\"php\", \"multiple declare directives\", nodeLocation(declarations[1], filename, source))\n  }\n\n  for (const declarationNode of declarations) {\n    const declaration = /** @type {import(\"php-parser\").Declare} */ (declarationNode)\n    const directive = declaration.directives[0]\n    const key = directive?.key\n    const value = directive?.value\n    const numericValue = value && typeof value == \"object\" && value.kind == \"number\"\n      ? /** @type {import(\"php-parser\").Number} */ (value)\n      : undefined\n    const valueIsOne = numericValue?.loc && source.slice(numericValue.loc.start.offset, numericValue.loc.end.offset) == \"1\"\n    const valid = declaration.mode == \"none\" && declaration.children.length == 0 && declaration.directives.length == 1 &&\n      key.kind == \"identifier\" && key.name == \"strict_types\" && valueIsOne\n\n    if (!valid) unsupportedSyntax(\"php\", \"declare other than strict_types=1\", nodeLocation(declaration, filename, source))\n  }\n}\n\n/**\n * Invokes php-parser and normalizes syntax failures.\n * @param {string} filename - Source filename.\n * @param {string} source - Source text.\n * @returns {import(\"php-parser\").Program} PHP program.\n */\nfunction parsePhpProgram(filename, source) {\n  try {\n    return parser.parseCode(source, filename)\n  } catch (error) {\n    return parseFailure(\"php\", error)\n  }\n}\n"]}