semantifold 0.1.0

package/build/src/frontends/ruby.js

@@ -0,0 +1,515 @@
+// @ts-check
+import { AndNode, CallNode, DefNode, ElseNode, FalseNode, IfNode, IntegerNode, InterpolatedStringNode, LocalVariableReadNode, LocalVariableWriteNode, OrNode, ParenthesesNode, ProgramNode, RequiredParameterNode, ReturnNode, StatementsNode, StringNode, TrueNode, loadPrism } from "@ruby/prism";
+import { missingType, SemantifoldDiagnostic, unsupportedSyntax } from "../diagnostic.js";
+import { locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset } from "../semantic/location.js";
+import { withAdaptedOperation } from "../semantic/operators.js";
+import { withParserRanges } from "../semantic/provenance.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { requireSourceScalarType } from "./scalars.js";
+const parsePrism = await loadPrism();
+const rubyBinaryOperations = new Map([
+    ["+", "Add"],
+    ["-", "Subtract"],
+    ["*", "Multiply"],
+    ["==", "Equal"],
+    ["!=", "NotEqual"],
+    ["<", "LessThan"],
+    ["<=", "LessThanOrEqual"],
+    [">", "GreaterThan"],
+    [">=", "GreaterThanOrEqual"]
+]);
+/**
+ * Returns a normalized Prism node location.
+ * @param {{location: import("@ruby/prism").Location}} node - Prism node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Source location.
+ */
+function nodeLocation(node, filename, source) {
+    return prismLocation(node.location, filename, source);
+}
+/**
+ * Converts a Prism location into a normalized source location.
+ * @param {import("@ruby/prism").Location} location - Prism location.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Source location.
+ */
+function prismLocation(location, filename, source) {
+    return locationFromOffsets(filename, source, utf8ByteOffsetToUtf16Offset(source, location.startOffset), utf8ByteOffsetToUtf16Offset(source, location.startOffset + location.length));
+}
+/**
+ * Slices JavaScript source using Prism's UTF-8 byte offsets.
+ * @param {string} source - Complete source.
+ * @param {number} startOffset - Inclusive Prism byte offset.
+ * @param {number} endOffset - Exclusive Prism byte offset.
+ * @returns {string} Source text in the byte range.
+ */
+function slicePrismSource(source, startOffset, endOffset) {
+    return source.slice(utf8ByteOffsetToUtf16Offset(source, startOffset), utf8ByteOffsetToUtf16Offset(source, endOffset));
+}
+/**
+ * Converts a supported Prism expression.
+ * @param {import("@ruby/prism").Node} node - Prism node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Expression} Semantic expression.
+ */
+function convertExpression(node, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node instanceof ParenthesesNode && node.body instanceof StatementsNode && node.body.body.length == 1) {
+        return convertExpression(node.body.body[0], filename, source);
+    }
+    if (node instanceof LocalVariableReadNode) {
+        return withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location, name: node.name }, { name: location });
+    }
+    if (node instanceof IntegerNode) {
+        if (!Number.isSafeInteger(node.value))
+            return unsupportedSyntax("ruby", "non-safe integer literal", location);
+        return withParserRanges({ kind: /** @type {const} */ ("IntegerLiteral"), location, value: node.value }, { literal: location });
+    }
+    if (node instanceof TrueNode || node instanceof FalseNode) {
+        return withParserRanges({ kind: /** @type {const} */ ("BooleanLiteral"), location, value: node instanceof TrueNode }, { literal: location });
+    }
+    if (node instanceof StringNode) {
+        const decoded = node.unescaped;
+        if (!decoded.validEncoding || decoded.encoding != "utf-8" || node.isForcedBinaryEncoding() ||
+            !hasOnlyUnicodeScalars(decoded.value)) {
+            return unsupportedSyntax("ruby", "invalid Unicode string literal", location);
+        }
+        return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: decoded.value }, { literal: location });
+    }
+    if (node instanceof InterpolatedStringNode)
+        return unsupportedSyntax("ruby", "interpolated string", location);
+    if (node instanceof CallNode && node.receiver && node.name == "!") {
+        const operatorLocation = prismLocation(node.messageLoc ?? node.location, filename, source);
+        if (node.callOperatorLoc)
+            return unsupportedSyntax("ruby", "qualified boolean not", operatorLocation);
+        if (node.messageLoc?.length != 1) {
+            return unsupportedSyntax("ruby", "precedence-sensitive boolean not", operatorLocation);
+        }
+        if (node.arguments_)
+            return unsupportedSyntax("ruby", "boolean not argument list", operatorLocation);
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand: convertExpression(node.receiver, filename, source)
+        }, { operator: operatorLocation }), "Not");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node instanceof CallNode && node.receiver && node.name == "-@") {
+        const operatorLocation = prismLocation(node.messageLoc ?? node.location, filename, source);
+        if (node.callOperatorLoc)
+            return unsupportedSyntax("ruby", "qualified integer negation", operatorLocation);
+        if (node.arguments_)
+            return unsupportedSyntax("ruby", "integer negation argument list", operatorLocation);
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand: convertExpression(node.receiver, filename, source)
+        }, { operator: operatorLocation }), "Negate");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node instanceof AndNode || node instanceof OrNode) {
+        const operatorLocation = prismLocation(node.operatorLoc, filename, source);
+        const sourceOperator = source.slice(operatorLocation.start.offset, operatorLocation.end.offset);
+        if (sourceOperator != "&&" && sourceOperator != "||") {
+            return unsupportedSyntax("ruby", `precedence-sensitive boolean ${sourceOperator}`, location);
+        }
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression",
+            left: convertExpression(node.left, filename, source),
+            location,
+            right: convertExpression(node.right, filename, source)
+        }, { operator: operatorLocation }), node instanceof AndNode ? "And" : "Or");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node instanceof CallNode && node.receiver && rubyBinaryOperations.has(node.name) && node.callOperatorLoc &&
+        node.arguments_?.arguments_.length == 1) {
+        return unsupportedSyntax("ruby", `qualified binary operator ${node.name}`, prismLocation(node.messageLoc ?? node.location, filename, source));
+    }
+    if (node instanceof CallNode && node.receiver && rubyBinaryOperations.has(node.name) && node.arguments_?.arguments_.length == 1) {
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression",
+            left: convertExpression(node.receiver, filename, source),
+            location,
+            right: convertExpression(node.arguments_.arguments_[0], filename, source)
+        }, { operator: prismLocation(node.messageLoc ?? node.location, filename, source) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (rubyBinaryOperations.get(node.name)));
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node instanceof CallNode && !node.receiver) {
+        return withParserRanges({
+            arguments: (node.arguments_?.arguments_ ?? []).map((argument) => convertExpression(argument, filename, source)),
+            callee: node.name,
+            kind: "CallExpression",
+            location
+        }, { callee: prismLocation(node.messageLoc ?? node.location, filename, source) });
+    }
+    return unsupportedSyntax("ruby", node.constructor.name, location);
+}
+/**
+ * Converts one explicit Ruby return.
+ * @param {import("@ruby/prism").Node} node - Prism 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 instanceof ReturnNode) || node.arguments_?.arguments_.length != 1) {
+        return unsupportedSyntax("ruby", node.constructor.name, location);
+    }
+    return {
+        expression: convertExpression(node.arguments_.arguments_[0], filename, source),
+        kind: "ReturnStatement",
+        location
+    };
+}
+/**
+ * Reads Prism-owned RBS-style type comments directly preceding a definition.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @param {{location: import("@ruby/prism").Location}} node - Comment owner.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {{parameters: Map<string, {location: import("../semantic/types.js").SourceLocation, sourceType: string}>, returnType: {location: import("../semantic/types.js").SourceLocation, sourceType: string} | undefined}} Declared types.
+ */
+function typeComments(comments, node, filename, source) {
+    const preceding = associatedComments(comments, node, source);
+    const parameterTypes = new Map();
+    /** @type {{location: import("../semantic/types.js").SourceLocation, sourceType: string} | undefined} */
+    let returnType;
+    for (const comment of preceding) {
+        const words = commentTokens(comment, filename, source);
+        if (words[0]?.text == "@param" && words.length == 3) {
+            parameterTypes.set(words[1].text, { location: words[2].location, sourceType: words[2].text });
+        }
+        if (words[0]?.text == "@return" && words.length == 2) {
+            returnType = { location: words[1].location, sourceType: words[1].text };
+        }
+    }
+    return { parameters: parameterTypes, returnType };
+}
+/**
+ * Lexes whitespace-separated metadata tokens inside a Prism-owned Ruby comment.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment} comment - Prism comment token.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {{location: import("../semantic/types.js").SourceLocation, text: string}[]} Metadata tokens.
+ */
+function commentTokens(comment, filename, source) {
+    const start = utf8ByteOffsetToUtf16Offset(source, comment.location.startOffset);
+    const end = utf8ByteOffsetToUtf16Offset(source, comment.location.startOffset + comment.location.length);
+    const tokens = [];
+    let offset = start + 1;
+    while (offset < end) {
+        while (offset < end && isRubyMetadataWhitespace(source[offset]))
+            offset++;
+        const tokenStart = offset;
+        while (offset < end && !isRubyMetadataWhitespace(source[offset]))
+            offset++;
+        if (tokenStart < offset) {
+            tokens.push({ location: locationFromOffsets(filename, source, tokenStart, offset), text: source.slice(tokenStart, offset) });
+        }
+    }
+    return tokens;
+}
+/**
+ * Checks one Ruby metadata separator.
+ * @param {string} character - Source character.
+ * @returns {boolean} Whether it separates metadata tokens.
+ */
+function isRubyMetadataWhitespace(character) {
+    return character == " " || character == "\t" || character == "\r" || character == "\n";
+}
+/**
+ * Selects only the contiguous comment block immediately before a definition.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @param {{location: import("@ruby/prism").Location}} node - Comment owner.
+ * @param {string} source - Complete source.
+ * @returns {import("@ruby/prism/src/deserialize.js").Comment[]} Associated comments.
+ */
+function associatedComments(comments, node, source) {
+    const preceding = comments.filter((comment) => comment.location.startOffset < node.location.startOffset)
+        .sort((left, right) => left.location.startOffset - right.location.startOffset);
+    const associated = [];
+    let boundary = node.location.startOffset;
+    for (let index = preceding.length - 1; index >= 0; index--) {
+        const comment = preceding[index];
+        const endOffset = comment.location.startOffset + comment.location.length;
+        const gap = slicePrismSource(source, endOffset, boundary);
+        if (!isImmediateCommentGap(gap))
+            break;
+        associated.unshift(comment);
+        boundary = comment.location.startOffset;
+    }
+    return associated;
+}
+/**
+ * Reads one exact Ruby local type carrier and immutability marker.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @param {LocalVariableWriteNode} node - Local write.
+ * @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(comments, node, filename, source) {
+    const associated = associatedComments(comments, node, source);
+    const metadata = associated.map((comment) => commentTokens(comment, filename, source));
+    const typeMetadata = metadata.filter(([token]) => token?.text == "@type");
+    const immutableMetadata = metadata.filter(([token]) => token?.text == "@semantifold-immutable");
+    const profileMetadata = metadata.filter(([token]) => {
+        return token?.text.startsWith("@type") || token?.text.startsWith("@semantifold-immutable");
+    });
+    if (profileMetadata.length == 0)
+        return undefined;
+    const location = nodeLocation(node, filename, source);
+    if (typeMetadata.length != 1 || typeMetadata[0].length != 2 ||
+        immutableMetadata.length > 1 || immutableMetadata.some((tokens) => tokens.length != 1) ||
+        profileMetadata.length != typeMetadata.length + immutableMetadata.length) {
+        return unsupportedSyntax("ruby", "malformed local type metadata", location);
+    }
+    return {
+        immutable: immutableMetadata.length == 1,
+        type: convertType(typeMetadata[0][1].text, `Local '${node.name}'`, location, typeMetadata[0][1].location)
+    };
+}
+/**
+ * Converts one Ruby local declaration or assignment.
+ * @param {import("@ruby/prism").Node} node - Prism node.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @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, comments, visible, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (!(node instanceof LocalVariableWriteNode))
+        return unsupportedSyntax("ruby", node.constructor.name, location);
+    const metadata = localMetadata(comments, node, filename, source);
+    if (metadata) {
+        visible.add(node.name);
+        return withParserRanges({
+            initializer: convertExpression(node.value, filename, source),
+            kind: "LocalDeclaration",
+            location,
+            mutable: !metadata.immutable,
+            name: node.name,
+            type: metadata.type
+        }, { name: prismLocation(node.nameLoc, filename, source), operator: prismLocation(node.operatorLoc, filename, source) });
+    }
+    if (!visible.has(node.name))
+        return missingType("ruby", `Local '${node.name}'`, location);
+    const targetLocation = prismLocation(node.nameLoc, filename, source);
+    const target = withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: targetLocation, name: node.name }, {
+        name: targetLocation
+    });
+    return withParserRanges({
+        expression: convertExpression(node.value, filename, source),
+        kind: "AssignmentStatement",
+        location,
+        target
+    }, { operator: prismLocation(node.operatorLoc, filename, source) });
+}
+/**
+ * Converts one exhaustive Prism statement.
+ * @param {import("@ruby/prism").Node} node - Prism statement.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @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, comments, visible, filename, source) {
+    if (node instanceof ReturnNode)
+        return convertReturn(node, filename, source);
+    if (node instanceof IfNode)
+        return convertIf(node, comments, visible, filename, source);
+    if (node instanceof LocalVariableWriteNode)
+        return convertLocalStatement(node, comments, visible, filename, source);
+    if (node instanceof CallNode)
+        return convertPrint(node, filename, source);
+    return unsupportedSyntax("ruby", node.constructor.name, nodeLocation(node, filename, source));
+}
+/**
+ * Converts one ordered Prism statement list.
+ * @param {StatementsNode | null} node - Prism statements, or an empty source block.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @param {Set<string>} visible - Names visible on block entry.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @param {import("../semantic/types.js").SourceLocation} fallbackLocation - Empty block location.
+ * @returns {import("../semantic/types.js").Block} Semantic block.
+ */
+function convertBlock(node, comments, visible, filename, source, fallbackLocation) {
+    return {
+        kind: "Block",
+        location: node ? nodeLocation(node, filename, source) : fallbackLocation,
+        statements: node ? node.body.map((statement) => convertStatement(statement, comments, visible, filename, source)) : []
+    };
+}
+/**
+ * Checks that a comment and its owner are separated by at most one newline.
+ * @param {string} gap - Source between the comment and following item.
+ * @returns {boolean} Whether the gap is immediate whitespace.
+ */
+function isImmediateCommentGap(gap) {
+    let newlines = 0;
+    for (const character of gap) {
+        if (character == "\n") {
+            newlines++;
+        }
+        else if (character != " " && character != "\t" && character != "\r") {
+            return false;
+        }
+    }
+    return newlines <= 1;
+}
+/**
+ * Requires an exact supported Ruby scalar spelling.
+ * @param {string | undefined} sourceType - Ruby type comment value.
+ * @param {string} subject - Typed subject.
+ * @param {import("../semantic/types.js").SourceLocation} location - Source location.
+ * @param {import("../semantic/types.js").SourceLocation} [typeLocation] - Exact type comment token location.
+ * @returns {import("../semantic/types.js").TypeReference} Semantic type.
+ */
+function convertType(sourceType, subject, location, typeLocation = location) {
+    return requireSourceScalarType("ruby", sourceType, subject, location, typeLocation);
+}
+/**
+ * Converts a Ruby definition.
+ * @param {DefNode} node - Prism definition.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+ */
+function convertFunction(node, comments, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (!node.parameters || node.parameters.optionals.length > 0 || node.parameters.rest || node.parameters.posts.length > 0 ||
+        node.parameters.keywords.length > 0 || node.parameters.keywordRest || node.parameters.block ||
+        node.parameters.requireds.some((parameter) => !(parameter instanceof RequiredParameterNode))) {
+        return unsupportedSyntax("ruby", "parameters", location);
+    }
+    const declaredTypes = typeComments(comments, node, filename, source);
+    const parameters = node.parameters.requireds.map((parameter) => {
+        if (!(parameter instanceof RequiredParameterNode))
+            return unsupportedSyntax("ruby", parameter.constructor.name, location);
+        const parameterLocation = nodeLocation(parameter, filename, source);
+        const declaredType = declaredTypes.parameters.get(parameter.name);
+        return withParserRanges({
+            kind: /** @type {const} */ ("Parameter"),
+            location: parameterLocation,
+            name: parameter.name,
+            type: convertType(declaredType?.sourceType, `Parameter '${parameter.name}'`, parameterLocation, declaredType?.location)
+        }, { name: parameterLocation });
+    });
+    const visible = new Set(parameters.map((parameter) => parameter.name));
+    const body = convertBlock(node.body instanceof StatementsNode ? node.body : null, comments, visible, filename, source, location);
+    return withParserRanges({
+        body,
+        kind: "FunctionDeclaration",
+        location,
+        name: node.name,
+        parameters,
+        returnType: convertType(declaredTypes.returnType?.sourceType, `Function '${node.name}' return`, location, declaredTypes.returnType?.location)
+    }, { name: prismLocation(node.nameLoc, filename, source) });
+}
+/**
+ * Converts the existing Ruby if/else terminal with restricted branch prefixes.
+ * @param {IfNode} node - Prism if node.
+ * @param {import("@ruby/prism/src/deserialize.js").Comment[]} comments - Prism comments.
+ * @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, comments, visible, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (!node.ifKeywordLoc || node.ifKeywordLoc.startOffset != node.location.startOffset) {
+        return unsupportedSyntax("ruby", "modifier conditional", node.ifKeywordLoc
+            ? prismLocation(node.ifKeywordLoc, filename, source)
+            : location);
+    }
+    const consequentVisible = new Set(visible);
+    let alternate;
+    if (node.subsequent) {
+        const alternateVisible = new Set(visible);
+        if (node.subsequent instanceof ElseNode) {
+            alternate = convertBlock(node.subsequent.statements, comments, alternateVisible, filename, source, nodeLocation(node.subsequent, filename, source));
+        }
+        else if (node.subsequent instanceof IfNode) {
+            alternate = {
+                kind: /** @type {const} */ ("Block"),
+                location: nodeLocation(node.subsequent, filename, source),
+                statements: [convertIf(node.subsequent, comments, alternateVisible, filename, source)]
+            };
+        }
+        else
+            return unsupportedSyntax("ruby", node.subsequent.constructor.name, nodeLocation(node.subsequent, filename, source));
+    }
+    return {
+        ...(alternate ? { alternate } : {}),
+        condition: convertExpression(node.predicate, filename, source),
+        consequent: convertBlock(node.statements, comments, consequentVisible, filename, source, location),
+        kind: "IfStatement",
+        location
+    };
+}
+/**
+ * Converts the supported Ruby puts entry point.
+ * @param {import("@ruby/prism").Node} node - Prism 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 instanceof CallNode) || node.receiver || node.name != "puts" || node.arguments_?.arguments_.length != 1) {
+        return unsupportedSyntax("ruby", node.constructor.name, location);
+    }
+    return { expression: convertExpression(node.arguments_.arguments_[0], filename, source), kind: "PrintStatement", location };
+}
+/**
+ * Parses Ruby 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 parseRuby({ filename, source }) {
+    const result = parsePrism(source, { filepath: filename });
+    if (result.errors.length > 0) {
+        const error = result.errors[0];
+        const location = locationFromOffsets(filename, source, error.location.startOffset, error.location.startOffset + error.location.length);
+        throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "ruby", location, message: error.message });
+    }
+    if (!(result.value instanceof ProgramNode))
+        throw new Error("Prism returned a non-program root.");
+    const body = result.value.statements.body;
+    const functions = body.filter((node) => node instanceof DefNode)
+        .map((node) => convertFunction(node, result.comments, filename, source));
+    const entryNodes = body.filter((node) => !(node instanceof DefNode));
+    const location = moduleLocation(filename, source);
+    if (functions.length == 0)
+        return unsupportedSyntax("ruby", "module without a function", location);
+    const firstEntry = entryNodes[0];
+    const entryLocation = firstEntry ? locationFromOffsets(filename, source, utf8ByteOffsetToUtf16Offset(source, firstEntry.location.startOffset), utf8ByteOffsetToUtf16Offset(source, (entryNodes.at(-1)?.location.startOffset ?? 0) + (entryNodes.at(-1)?.location.length ?? 0))) : location;
+    const entryVisible = new Set();
+    const entryBlock = {
+        kind: /** @type {const} */ ("Block"),
+        location: entryLocation,
+        statements: entryNodes.map((statement) => convertStatement(statement, result.comments, entryVisible, filename, source))
+    };
+    return {
+        entryPoint: {
+            body: entryBlock,
+            kind: "EntryPoint",
+            location: entryLocation
+        },
+        functions,
+        kind: "Module",
+        location
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ruby.js","sourceRoot":"","sources":["../../../src/frontends/ruby.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {\n  AndNode,\n  CallNode,\n  DefNode,\n  ElseNode,\n  FalseNode,\n  IfNode,\n  IntegerNode,\n  InterpolatedStringNode,\n  LocalVariableReadNode,\n  LocalVariableWriteNode,\n  OrNode,\n  ParenthesesNode,\n  ProgramNode,\n  RequiredParameterNode,\n  ReturnNode,\n  StatementsNode,\n  StringNode,\n  TrueNode,\n  loadPrism\n} from \"@ruby/prism\"\nimport {missingType, SemantifoldDiagnostic, unsupportedSyntax} from \"../diagnostic.js\"\nimport {locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset} from \"../semantic/location.js\"\nimport {withAdaptedOperation} from \"../semantic/operators.js\"\nimport {withParserRanges} from \"../semantic/provenance.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {requireSourceScalarType} from \"./scalars.js\"\nconst parsePrism = await loadPrism()\nconst rubyBinaryOperations = new Map([\n  [\"+\", \"Add\"],\n  [\"-\", \"Subtract\"],\n  [\"*\", \"Multiply\"],\n  [\"==\", \"Equal\"],\n  [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"],\n  [\"<=\", \"LessThanOrEqual\"],\n  [\">\", \"GreaterThan\"],\n  [\">=\", \"GreaterThanOrEqual\"]\n])\n\n/**\n * Returns a normalized Prism node location.\n * @param {{location: import(\"@ruby/prism\").Location}} node - Prism 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  return prismLocation(node.location, filename, source)\n}\n\n/**\n * Converts a Prism location into a normalized source location.\n * @param {import(\"@ruby/prism\").Location} location - Prism location.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Source location.\n */\nfunction prismLocation(location, filename, source) {\n  return locationFromOffsets(\n    filename,\n    source,\n    utf8ByteOffsetToUtf16Offset(source, location.startOffset),\n    utf8ByteOffsetToUtf16Offset(source, location.startOffset + location.length)\n  )\n}\n\n/**\n * Slices JavaScript source using Prism's UTF-8 byte offsets.\n * @param {string} source - Complete source.\n * @param {number} startOffset - Inclusive Prism byte offset.\n * @param {number} endOffset - Exclusive Prism byte offset.\n * @returns {string} Source text in the byte range.\n */\nfunction slicePrismSource(source, startOffset, endOffset) {\n  return source.slice(\n    utf8ByteOffsetToUtf16Offset(source, startOffset),\n    utf8ByteOffsetToUtf16Offset(source, endOffset)\n  )\n}\n\n/**\n * Converts a supported Prism expression.\n * @param {import(\"@ruby/prism\").Node} node - Prism node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n */\nfunction convertExpression(node, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node instanceof ParenthesesNode && node.body instanceof StatementsNode && node.body.body.length == 1) {\n    return convertExpression(node.body.body[0], filename, source)\n  }\n\n  if (node instanceof LocalVariableReadNode) {\n    return withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location, name: node.name}, {name: location})\n  }\n\n  if (node instanceof IntegerNode) {\n    if (!Number.isSafeInteger(node.value)) return unsupportedSyntax(\"ruby\", \"non-safe integer literal\", location)\n\n    return withParserRanges({kind: /** @type {const} */ (\"IntegerLiteral\"), location, value: node.value}, {literal: location})\n  }\n\n  if (node instanceof TrueNode || node instanceof FalseNode) {\n    return withParserRanges({kind: /** @type {const} */ (\"BooleanLiteral\"), location, value: node instanceof TrueNode}, {literal: location})\n  }\n\n  if (node instanceof StringNode) {\n    const decoded = node.unescaped\n\n    if (!decoded.validEncoding || decoded.encoding != \"utf-8\" || node.isForcedBinaryEncoding() ||\n      !hasOnlyUnicodeScalars(decoded.value)) {\n      return unsupportedSyntax(\"ruby\", \"invalid Unicode string literal\", location)\n    }\n\n    return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: decoded.value}, {literal: location})\n  }\n\n  if (node instanceof InterpolatedStringNode) return unsupportedSyntax(\"ruby\", \"interpolated string\", location)\n\n  if (node instanceof CallNode && node.receiver && node.name == \"!\") {\n    const operatorLocation = prismLocation(node.messageLoc ?? node.location, filename, source)\n\n    if (node.callOperatorLoc) return unsupportedSyntax(\"ruby\", \"qualified boolean not\", operatorLocation)\n    if (node.messageLoc?.length != 1) {\n      return unsupportedSyntax(\"ruby\", \"precedence-sensitive boolean not\", operatorLocation)\n    }\n    if (node.arguments_) return unsupportedSyntax(\"ruby\", \"boolean not argument list\", operatorLocation)\n\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand: convertExpression(node.receiver, filename, source)\n    }, {operator: operatorLocation}), \"Not\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node instanceof CallNode && node.receiver && node.name == \"-@\") {\n    const operatorLocation = prismLocation(node.messageLoc ?? node.location, filename, source)\n\n    if (node.callOperatorLoc) return unsupportedSyntax(\"ruby\", \"qualified integer negation\", operatorLocation)\n    if (node.arguments_) return unsupportedSyntax(\"ruby\", \"integer negation argument list\", operatorLocation)\n\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand: convertExpression(node.receiver, filename, source)\n    }, {operator: operatorLocation}), \"Negate\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node instanceof AndNode || node instanceof OrNode) {\n    const operatorLocation = prismLocation(node.operatorLoc, filename, source)\n    const sourceOperator = source.slice(operatorLocation.start.offset, operatorLocation.end.offset)\n\n    if (sourceOperator != \"&&\" && sourceOperator != \"||\") {\n      return unsupportedSyntax(\"ruby\", `precedence-sensitive boolean ${sourceOperator}`, location)\n    }\n\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\",\n      left: convertExpression(node.left, filename, source),\n      location,\n      right: convertExpression(node.right, filename, source)\n    }, {operator: operatorLocation}), node instanceof AndNode ? \"And\" : \"Or\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node instanceof CallNode && node.receiver && rubyBinaryOperations.has(node.name) && node.callOperatorLoc &&\n    node.arguments_?.arguments_.length == 1) {\n    return unsupportedSyntax(\n      \"ruby\",\n      `qualified binary operator ${node.name}`,\n      prismLocation(node.messageLoc ?? node.location, filename, source)\n    )\n  }\n\n  if (node instanceof CallNode && node.receiver && rubyBinaryOperations.has(node.name) && node.arguments_?.arguments_.length == 1) {\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\",\n      left: convertExpression(node.receiver, filename, source),\n      location,\n      right: convertExpression(node.arguments_.arguments_[0], filename, source)\n    }, {operator: prismLocation(node.messageLoc ?? node.location, filename, source)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (rubyBinaryOperations.get(node.name)))\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node instanceof CallNode && !node.receiver) {\n    return withParserRanges({\n      arguments: (node.arguments_?.arguments_ ?? []).map((argument) => convertExpression(argument, filename, source)),\n      callee: node.name,\n      kind: \"CallExpression\",\n      location\n    }, {callee: prismLocation(node.messageLoc ?? node.location, filename, source)})\n  }\n\n  return unsupportedSyntax(\"ruby\", node.constructor.name, location)\n}\n\n/**\n * Converts one explicit Ruby return.\n * @param {import(\"@ruby/prism\").Node} node - Prism 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 instanceof ReturnNode) || node.arguments_?.arguments_.length != 1) {\n    return unsupportedSyntax(\"ruby\", node.constructor.name, location)\n  }\n\n  return {\n    expression: convertExpression(node.arguments_.arguments_[0], filename, source),\n    kind: \"ReturnStatement\",\n    location\n  }\n}\n\n/**\n * Reads Prism-owned RBS-style type comments directly preceding a definition.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment[]} comments - Prism comments.\n * @param {{location: import(\"@ruby/prism\").Location}} node - Comment owner.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {{parameters: Map<string, {location: import(\"../semantic/types.js\").SourceLocation, sourceType: string}>, returnType: {location: import(\"../semantic/types.js\").SourceLocation, sourceType: string} | undefined}} Declared types.\n */\nfunction typeComments(comments, node, filename, source) {\n  const preceding = associatedComments(comments, node, source)\n  const parameterTypes = new Map()\n  /** @type {{location: import(\"../semantic/types.js\").SourceLocation, sourceType: string} | undefined} */\n  let returnType\n\n  for (const comment of preceding) {\n    const words = commentTokens(comment, filename, source)\n\n    if (words[0]?.text == \"@param\" && words.length == 3) {\n      parameterTypes.set(words[1].text, {location: words[2].location, sourceType: words[2].text})\n    }\n    if (words[0]?.text == \"@return\" && words.length == 2) {\n      returnType = {location: words[1].location, sourceType: words[1].text}\n    }\n  }\n\n  return {parameters: parameterTypes, returnType}\n}\n\n/**\n * Lexes whitespace-separated metadata tokens inside a Prism-owned Ruby comment.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment} comment - Prism comment token.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {{location: import(\"../semantic/types.js\").SourceLocation, text: string}[]} Metadata tokens.\n */\nfunction commentTokens(comment, filename, source) {\n  const start = utf8ByteOffsetToUtf16Offset(source, comment.location.startOffset)\n  const end = utf8ByteOffsetToUtf16Offset(source, comment.location.startOffset + comment.location.length)\n  const tokens = []\n  let offset = start + 1\n\n  while (offset < end) {\n    while (offset < end && isRubyMetadataWhitespace(source[offset])) offset++\n    const tokenStart = offset\n\n    while (offset < end && !isRubyMetadataWhitespace(source[offset])) offset++\n    if (tokenStart < offset) {\n      tokens.push({location: locationFromOffsets(filename, source, tokenStart, offset), text: source.slice(tokenStart, offset)})\n    }\n  }\n\n  return tokens\n}\n\n/**\n * Checks one Ruby metadata separator.\n * @param {string} character - Source character.\n * @returns {boolean} Whether it separates metadata tokens.\n */\nfunction isRubyMetadataWhitespace(character) {\n  return character == \" \" || character == \"\\t\" || character == \"\\r\" || character == \"\\n\"\n}\n\n/**\n * Selects only the contiguous comment block immediately before a definition.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment[]} comments - Prism comments.\n * @param {{location: import(\"@ruby/prism\").Location}} node - Comment owner.\n * @param {string} source - Complete source.\n * @returns {import(\"@ruby/prism/src/deserialize.js\").Comment[]} Associated comments.\n */\nfunction associatedComments(comments, node, source) {\n  const preceding = comments.filter((comment) => comment.location.startOffset < node.location.startOffset)\n    .sort((left, right) => left.location.startOffset - right.location.startOffset)\n  const associated = []\n  let boundary = node.location.startOffset\n\n  for (let index = preceding.length - 1; index >= 0; index--) {\n    const comment = preceding[index]\n    const endOffset = comment.location.startOffset + comment.location.length\n    const gap = slicePrismSource(source, endOffset, boundary)\n\n    if (!isImmediateCommentGap(gap)) break\n\n    associated.unshift(comment)\n    boundary = comment.location.startOffset\n  }\n\n  return associated\n}\n\n/**\n * Reads one exact Ruby local type carrier and immutability marker.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment[]} comments - Prism comments.\n * @param {LocalVariableWriteNode} node - Local write.\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(comments, node, filename, source) {\n  const associated = associatedComments(comments, node, source)\n  const metadata = associated.map((comment) => commentTokens(comment, filename, source))\n  const typeMetadata = metadata.filter(([token]) => token?.text == \"@type\")\n  const immutableMetadata = metadata.filter(([token]) => token?.text == \"@semantifold-immutable\")\n  const profileMetadata = metadata.filter(([token]) => {\n    return token?.text.startsWith(\"@type\") || token?.text.startsWith(\"@semantifold-immutable\")\n  })\n\n  if (profileMetadata.length == 0) return undefined\n\n  const location = nodeLocation(node, filename, source)\n\n  if (typeMetadata.length != 1 || typeMetadata[0].length != 2 ||\n    immutableMetadata.length > 1 || immutableMetadata.some((tokens) => tokens.length != 1) ||\n    profileMetadata.length != typeMetadata.length + immutableMetadata.length) {\n    return unsupportedSyntax(\"ruby\", \"malformed local type metadata\", location)\n  }\n\n  return {\n    immutable: immutableMetadata.length == 1,\n    type: convertType(typeMetadata[0][1].text, `Local '${node.name}'`, location, typeMetadata[0][1].location)\n  }\n}\n\n/**\n * Converts one Ruby local declaration or assignment.\n * @param {import(\"@ruby/prism\").Node} node - Prism node.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment[]} comments - Prism comments.\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, comments, visible, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (!(node instanceof LocalVariableWriteNode)) return unsupportedSyntax(\"ruby\", node.constructor.name, location)\n\n  const metadata = localMetadata(comments, node, filename, source)\n\n  if (metadata) {\n    visible.add(node.name)\n    return withParserRanges({\n      initializer: convertExpression(node.value, filename, source),\n      kind: \"LocalDeclaration\",\n      location,\n      mutable: !metadata.immutable,\n      name: node.name,\n      type: metadata.type\n    }, {name: prismLocation(node.nameLoc, filename, source), operator: prismLocation(node.operatorLoc, filename, source)})\n  }\n\n  if (!visible.has(node.name)) return missingType(\"ruby\", `Local '${node.name}'`, location)\n\n  const targetLocation = prismLocation(node.nameLoc, filename, source)\n  const target = withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: targetLocation, name: node.name}, {\n    name: targetLocation\n  })\n\n  return withParserRanges({\n    expression: convertExpression(node.value, filename, source),\n    kind: \"AssignmentStatement\",\n    location,\n    target\n  }, {operator: prismLocation(node.operatorLoc, filename, source)})\n}\n\n/**\n * Converts one exhaustive Prism statement.\n * @param {import(\"@ruby/prism\").Node} node - Prism statement.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment[]} comments - Prism comments.\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, comments, visible, filename, source) {\n  if (node instanceof ReturnNode) return convertReturn(node, filename, source)\n  if (node instanceof IfNode) return convertIf(node, comments, visible, filename, source)\n  if (node instanceof LocalVariableWriteNode) return convertLocalStatement(node, comments, visible, filename, source)\n  if (node instanceof CallNode) return convertPrint(node, filename, source)\n\n  return unsupportedSyntax(\"ruby\", node.constructor.name, nodeLocation(node, filename, source))\n}\n\n/**\n * Converts one ordered Prism statement list.\n * @param {StatementsNode | null} node - Prism statements, or an empty source block.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment[]} comments - Prism comments.\n * @param {Set<string>} visible - Names visible on block entry.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @param {import(\"../semantic/types.js\").SourceLocation} fallbackLocation - Empty block location.\n * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n */\nfunction convertBlock(node, comments, visible, filename, source, fallbackLocation) {\n  return {\n    kind: \"Block\",\n    location: node ? nodeLocation(node, filename, source) : fallbackLocation,\n    statements: node ? node.body.map((statement) => convertStatement(statement, comments, visible, filename, source)) : []\n  }\n}\n\n/**\n * Checks that a comment and its owner are separated by at most one newline.\n * @param {string} gap - Source between the comment and following item.\n * @returns {boolean} Whether the gap is immediate whitespace.\n */\nfunction isImmediateCommentGap(gap) {\n  let newlines = 0\n\n  for (const character of gap) {\n    if (character == \"\\n\") {\n      newlines++\n    } else if (character != \" \" && character != \"\\t\" && character != \"\\r\") {\n      return false\n    }\n  }\n\n  return newlines <= 1\n}\n\n/**\n * Requires an exact supported Ruby scalar spelling.\n * @param {string | undefined} sourceType - Ruby type comment value.\n * @param {string} subject - Typed subject.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Source location.\n * @param {import(\"../semantic/types.js\").SourceLocation} [typeLocation] - Exact type comment token location.\n * @returns {import(\"../semantic/types.js\").TypeReference} Semantic type.\n */\nfunction convertType(sourceType, subject, location, typeLocation = location) {\n  return requireSourceScalarType(\"ruby\", sourceType, subject, location, typeLocation)\n}\n\n/**\n * Converts a Ruby definition.\n * @param {DefNode} node - Prism definition.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment[]} comments - Prism comments.\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, comments, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (!node.parameters || node.parameters.optionals.length > 0 || node.parameters.rest || node.parameters.posts.length > 0 ||\n    node.parameters.keywords.length > 0 || node.parameters.keywordRest || node.parameters.block ||\n    node.parameters.requireds.some((parameter) => !(parameter instanceof RequiredParameterNode))) {\n    return unsupportedSyntax(\"ruby\", \"parameters\", location)\n  }\n\n  const declaredTypes = typeComments(comments, node, filename, source)\n  const parameters = node.parameters.requireds.map((parameter) => {\n    if (!(parameter instanceof RequiredParameterNode)) return unsupportedSyntax(\"ruby\", parameter.constructor.name, location)\n\n    const parameterLocation = nodeLocation(parameter, filename, source)\n\n    const declaredType = declaredTypes.parameters.get(parameter.name)\n\n    return withParserRanges({\n      kind: /** @type {const} */ (\"Parameter\"),\n      location: parameterLocation,\n      name: parameter.name,\n      type: convertType(declaredType?.sourceType, `Parameter '${parameter.name}'`, parameterLocation, declaredType?.location)\n    }, {name: parameterLocation})\n  })\n  const visible = new Set(parameters.map((parameter) => parameter.name))\n  const body = convertBlock(node.body instanceof StatementsNode ? node.body : null, comments, visible, filename, source, location)\n\n  return withParserRanges({\n    body,\n    kind: \"FunctionDeclaration\",\n    location,\n    name: node.name,\n    parameters,\n    returnType: convertType(declaredTypes.returnType?.sourceType, `Function '${node.name}' return`, location, declaredTypes.returnType?.location)\n  }, {name: prismLocation(node.nameLoc, filename, source)})\n}\n\n/**\n * Converts the existing Ruby if/else terminal with restricted branch prefixes.\n * @param {IfNode} node - Prism if node.\n * @param {import(\"@ruby/prism/src/deserialize.js\").Comment[]} comments - Prism comments.\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, comments, visible, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (!node.ifKeywordLoc || node.ifKeywordLoc.startOffset != node.location.startOffset) {\n    return unsupportedSyntax(\"ruby\", \"modifier conditional\", node.ifKeywordLoc\n      ? prismLocation(node.ifKeywordLoc, filename, source)\n      : location)\n  }\n\n  const consequentVisible = new Set(visible)\n  let alternate\n\n  if (node.subsequent) {\n    const alternateVisible = new Set(visible)\n\n    if (node.subsequent instanceof ElseNode) {\n      alternate = convertBlock(node.subsequent.statements, comments, alternateVisible, filename, source,\n        nodeLocation(node.subsequent, filename, source))\n    } else if (node.subsequent instanceof IfNode) {\n      alternate = {\n        kind: /** @type {const} */ (\"Block\"),\n        location: nodeLocation(node.subsequent, filename, source),\n        statements: [convertIf(node.subsequent, comments, alternateVisible, filename, source)]\n      }\n    } else return unsupportedSyntax(\"ruby\", node.subsequent.constructor.name, nodeLocation(node.subsequent, filename, source))\n  }\n\n  return {\n    ...(alternate ? {alternate} : {}),\n    condition: convertExpression(node.predicate, filename, source),\n    consequent: convertBlock(node.statements, comments, consequentVisible, filename, source, location),\n    kind: \"IfStatement\",\n    location\n  }\n}\n\n/**\n * Converts the supported Ruby puts entry point.\n * @param {import(\"@ruby/prism\").Node} node - Prism 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 instanceof CallNode) || node.receiver || node.name != \"puts\" || node.arguments_?.arguments_.length != 1) {\n    return unsupportedSyntax(\"ruby\", node.constructor.name, location)\n  }\n\n  return {expression: convertExpression(node.arguments_.arguments_[0], filename, source), kind: \"PrintStatement\", location}\n}\n\n/**\n * Parses Ruby 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 parseRuby({filename, source}) {\n  const result = parsePrism(source, {filepath: filename})\n\n  if (result.errors.length > 0) {\n    const error = result.errors[0]\n    const location = locationFromOffsets(filename, source, error.location.startOffset, error.location.startOffset + error.location.length)\n\n    throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"ruby\", location, message: error.message})\n  }\n\n  if (!(result.value instanceof ProgramNode)) throw new Error(\"Prism returned a non-program root.\")\n\n  const body = result.value.statements.body\n  const functions = body.filter((node) => node instanceof DefNode)\n    .map((node) => convertFunction(node, result.comments, filename, source))\n  const entryNodes = body.filter((node) => !(node instanceof DefNode))\n  const location = moduleLocation(filename, source)\n\n  if (functions.length == 0) return unsupportedSyntax(\"ruby\", \"module without a function\", location)\n  const firstEntry = entryNodes[0]\n  const entryLocation = firstEntry ? locationFromOffsets(\n    filename,\n    source,\n    utf8ByteOffsetToUtf16Offset(source, firstEntry.location.startOffset),\n    utf8ByteOffsetToUtf16Offset(\n      source,\n      (entryNodes.at(-1)?.location.startOffset ?? 0) + (entryNodes.at(-1)?.location.length ?? 0)\n    )\n  ) : location\n  const entryVisible = new Set()\n  const entryBlock = {\n    kind: /** @type {const} */ (\"Block\"),\n    location: entryLocation,\n    statements: entryNodes.map((statement) => convertStatement(statement, result.comments, 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"]}