@rank-lang/lsp 0.3.0

package/README.md

@@ -0,0 +1,46 @@
+# @rank-lang/lsp
+
+Language Server Protocol implementation for Rank.
+
+**[Full documentation →](https://rank-lang.com/)**
+
+## Status
+
+This is a core workspace package used by the VS Code extension and the shared CLI/runtime toolchain.
+
+## Surface
+
+- executable entrypoint: `rank-lsp`
+- transport: stdio
+- document sync: incremental
+- editor features: diagnostics, hover, go-to-definition, and completion
+
+## Diagnostic suppression
+
+For intentionally invalid fixtures, the LSP supports declaration-scoped suppression with doc comments:
+
+```rank
+/// rank-ignore NAM002 NAM005
+value: Missing<string> = missing_value
+```
+
+This filters only the published LSP diagnostics for the annotated top-level declaration. The compiler still evaluates the file and still emits the underlying diagnostics for non-LSP tooling.
+
+The server is implemented in `src/server.ts` and wires requests into compiler-backed feature handlers through `ProjectSession`.
+
+## Running locally
+
+```sh
+npm run build -w @rank-lang/lsp
+node packages/lsp/dist/server.js
+```
+
+In practice this package is normally launched by `rank-language-support` rather than by hand.
+
+## Development
+
+```sh
+npm run build -w @rank-lang/lsp
+npm run test -w @rank-lang/lsp
+npm run typecheck -w @rank-lang/lsp
+```

package/dist/features/completion.d.ts

@@ -0,0 +1,4 @@
+import type { CompletionItem as LspCompletionItem, TextDocumentPositionParams } from "vscode-languageserver/node.js";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import type { ProjectSession } from "../session.js";
+export declare function handleCompletion(params: TextDocumentPositionParams, session: ProjectSession, document?: TextDocument): Promise<LspCompletionItem[]>;

package/dist/features/completion.js

@@ -0,0 +1,23 @@
+import { completionItemsAtPosition } from "@rank-lang/compiler";
+import { CompletionItemKind } from "vscode-languageserver/node.js";
+import { fileURLToPath } from "node:url";
+import { toSourcePosition } from "../util/convert.js";
+export async function handleCompletion(params, session, document) {
+    const filePath = fileURLToPath(params.textDocument.uri);
+    const graph = await session.getModuleGraph(filePath);
+    if (!graph)
+        return [];
+    const mod = session.getLoadedModule(graph, filePath);
+    if (!mod)
+        return [];
+    const position = toSourcePosition(params.position, document);
+    const items = completionItemsAtPosition(graph, mod, position);
+    return items.map((item) => ({
+        label: item.label,
+        kind: item.kind === "type"
+            ? CompletionItemKind.Class
+            : item.kind === "keyword"
+                ? CompletionItemKind.Keyword
+                : CompletionItemKind.Variable,
+    }));
+}

package/dist/features/definition.d.ts

@@ -0,0 +1,4 @@
+import type { TextDocumentPositionParams, Location } from "vscode-languageserver/node.js";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import type { ProjectSession } from "../session.js";
+export declare function handleDefinition(params: TextDocumentPositionParams, session: ProjectSession, document?: TextDocument): Promise<Location | null>;

package/dist/features/definition.js

@@ -0,0 +1,32 @@
+import { findDefinitionAtPosition } from "@rank-lang/compiler";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { toSourcePosition, toLspRange } from "../util/convert.js";
+import { findTypeSymbolAtPosition } from "../util/type-symbols.js";
+export async function handleDefinition(params, session, document) {
+    const filePath = fileURLToPath(params.textDocument.uri);
+    const graph = await session.getModuleGraph(filePath);
+    if (!graph)
+        return null;
+    const mod = session.getLoadedModule(graph, filePath);
+    if (!mod)
+        return null;
+    const position = toSourcePosition(params.position, document);
+    const definition = findDefinitionAtPosition(graph, mod, position);
+    if (definition) {
+        return {
+            uri: pathToFileURL(definition.filePath).href,
+            range: toLspRange(definition.span),
+        };
+    }
+    if (!document) {
+        return null;
+    }
+    const typeSymbol = findTypeSymbolAtPosition(document, params.position, graph, mod);
+    if (!typeSymbol) {
+        return null;
+    }
+    return {
+        uri: pathToFileURL(typeSymbol.filePath).href,
+        range: toLspRange(typeSymbol.span),
+    };
+}

package/dist/features/diagnostics.d.ts

@@ -0,0 +1,3 @@
+import type { Connection } from "vscode-languageserver/node.js";
+import type { ProjectSession } from "../session.js";
+export declare function publishDiagnostics(connection: Connection, session: ProjectSession, filePath: string): Promise<void>;

package/dist/features/diagnostics.js

@@ -0,0 +1,133 @@
+import { resolveModuleImports, resolveModuleReferences, resolveModuleTypeNames, checkModuleTypes, } from "@rank-lang/compiler";
+import { collectRankServerAppSurfaceDiagnostics } from "@rank-lang/server-runtime";
+import { pathToFileURL } from "node:url";
+import { toLspDiagnostic } from "../util/convert.js";
+function parseIgnoredDiagnosticCodes(documentation) {
+    const codes = new Set();
+    for (const line of documentation) {
+        const match = /^rank-ignore\b(.*)$/u.exec(line.trim());
+        if (!match) {
+            continue;
+        }
+        for (const code of (match[1] ?? "").split(/[\s,]+/u).map((value) => value.trim()).filter((value) => value.length > 0)) {
+            codes.add(code);
+        }
+    }
+    return codes;
+}
+function declarationStartOffset(declaration) {
+    switch (declaration.kind) {
+        case "ValueBindingDeclaration":
+        case "TypeAliasDeclaration":
+            return declaration.nameSpan?.start.offset;
+        case "DestructuringBindingDeclaration":
+            return declaration.fieldSpans
+                ? Math.min(...Object.values(declaration.fieldSpans).map((span) => span.start.offset))
+                : undefined;
+    }
+}
+function collectDiagnosticSuppressions(loadedModule) {
+    const declarationsWithStarts = loadedModule.program.declarations.map((declaration) => ({
+        declaration,
+        startOffset: declarationStartOffset(declaration),
+    }));
+    const suppressions = [];
+    for (let index = 0; index < declarationsWithStarts.length; index += 1) {
+        const current = declarationsWithStarts[index];
+        if (!current) {
+            continue;
+        }
+        const startOffset = current.startOffset;
+        if (startOffset === undefined) {
+            continue;
+        }
+        const codes = parseIgnoredDiagnosticCodes(current.declaration.documentation);
+        if (codes.size === 0) {
+            continue;
+        }
+        const nextStartOffset = declarationsWithStarts
+            .slice(index + 1)
+            .map((candidate) => candidate.startOffset)
+            .find((candidate) => candidate !== undefined);
+        suppressions.push({
+            startOffset,
+            endOffset: nextStartOffset ?? Number.POSITIVE_INFINITY,
+            codes,
+        });
+    }
+    return suppressions;
+}
+function isSuppressedDiagnostic(diagnostic, suppressions) {
+    if (!diagnostic.span) {
+        return false;
+    }
+    return suppressions.some((suppression) => (diagnostic.span.start.offset >= suppression.startOffset
+        && diagnostic.span.start.offset < suppression.endOffset
+        && suppression.codes.has(diagnostic.code)));
+}
+function exportedValueDeclaration(loadedModule, name) {
+    return loadedModule.program.declarations.find((declaration) => declaration.kind === "ValueBindingDeclaration"
+        && declaration.visibility === "pub"
+        && declaration.name === name);
+}
+function isExecutionContextTypeName(name) {
+    return name === "ExecutionContext"
+        || name === "Runtime::ExecutionContext"
+        || name === "std::Runtime::ExecutionContext";
+}
+function isServeExecutionContextTypeAnnotation(typeNode) {
+    return !!typeNode
+        && typeNode.kind === "GenericType"
+        && typeNode.arguments.length === 1
+        && isExecutionContextTypeName(typeNode.name);
+}
+function shouldPublishServeDiagnostics(loadedModule) {
+    if (exportedValueDeclaration(loadedModule, "config")) {
+        return true;
+    }
+    const mainDeclaration = exportedValueDeclaration(loadedModule, "main");
+    return !!mainDeclaration
+        && mainDeclaration.value.kind === "FunctionExpression"
+        && (mainDeclaration.value.parameters.length === 0
+            || (mainDeclaration.value.parameters.length === 1
+                && isServeExecutionContextTypeAnnotation(mainDeclaration.value.parameters[0]?.typeAnnotation)));
+}
+export async function publishDiagnostics(connection, session, filePath) {
+    const graph = await session.getModuleGraph(filePath);
+    if (!graph) {
+        return;
+    }
+    const importDiagnostics = resolveModuleImports(graph);
+    const refDiagnostics = resolveModuleReferences(graph);
+    const typeDiagnostics = resolveModuleTypeNames(graph);
+    const checkDiagnostics = checkModuleTypes(graph, await session.getTypeCheckOptions(filePath, graph));
+    const entryModule = graph.modules[graph.entryModulePath];
+    const serveDiagnostics = entryModule && shouldPublishServeDiagnostics(entryModule)
+        ? collectRankServerAppSurfaceDiagnostics(graph, entryModule.filePath)
+        : [];
+    const allDiagnostics = [
+        ...graph.diagnostics,
+        ...importDiagnostics,
+        ...refDiagnostics,
+        ...typeDiagnostics,
+        ...checkDiagnostics,
+        ...serveDiagnostics,
+    ];
+    // Group diagnostics by source file and publish per-file.
+    const byFile = new Map();
+    for (const d of allDiagnostics) {
+        let list = byFile.get(d.sourcePath);
+        if (!list) {
+            list = [];
+            byFile.set(d.sourcePath, list);
+        }
+        list.push(d);
+    }
+    // Publish for the affected file and clear any files with no diagnostics.
+    for (const mod of Object.values(graph.modules)) {
+        const uri = pathToFileURL(mod.filePath).href;
+        const suppressions = collectDiagnosticSuppressions(mod);
+        const diags = (byFile.get(mod.filePath) ?? []).filter((diagnostic) => !isSuppressedDiagnostic(diagnostic, suppressions));
+        connection.sendDiagnostics({ uri, diagnostics: diags.map(toLspDiagnostic) });
+    }
+}

package/dist/features/hover.d.ts

@@ -0,0 +1,4 @@
+import type { TextDocumentPositionParams, Hover } from "vscode-languageserver/node.js";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import type { ProjectSession } from "../session.js";
+export declare function handleHover(params: TextDocumentPositionParams, session: ProjectSession, document?: TextDocument): Promise<Hover | null>;

package/dist/features/hover.js

@@ -0,0 +1,75 @@
+import { hoverInfoAtPosition, queryModuleBindingType, } from "@rank-lang/compiler";
+import { collectRankServerAppSurfaceDiagnostics } from "@rank-lang/server-runtime";
+import { fileURLToPath } from "node:url";
+import { toSourcePosition } from "../util/convert.js";
+import { findStdlibHoverAtPosition } from "../util/stdlib-hover.js";
+import { findTypeSymbolAtPosition, formatTypeNode } from "../util/type-symbols.js";
+function containsPosition(span, position) {
+    return !!span && span.start.offset <= position.offset && position.offset < span.end.offset;
+}
+function exportedValueDeclaration(loadedModule, name) {
+    return loadedModule.program.declarations.find((declaration) => declaration.kind === "ValueBindingDeclaration"
+        && declaration.visibility === "pub"
+        && declaration.name === name);
+}
+function serveConfigHoverAtPosition(moduleGraph, loadedModule, position) {
+    const entryModule = moduleGraph.modules[moduleGraph.entryModulePath];
+    if (!entryModule || entryModule.filePath !== loadedModule.filePath) {
+        return null;
+    }
+    const configDeclaration = exportedValueDeclaration(loadedModule, "config");
+    if (!configDeclaration || !containsPosition(configDeclaration.nameSpan, position)) {
+        return null;
+    }
+    const actualType = queryModuleBindingType(moduleGraph, loadedModule, "config", false);
+    if (!actualType) {
+        return null;
+    }
+    const serveDiagnostics = collectRankServerAppSurfaceDiagnostics(moduleGraph, loadedModule.filePath);
+    const lines = [
+        "```rank",
+        `config: ${actualType}`,
+        "```",
+        "",
+        "Serve config expects `HTTP::AppConfig` or `() -> HTTP::AppConfig`.",
+    ];
+    if (serveDiagnostics.some((diagnostic) => diagnostic.code === "SRV004")) {
+        lines.push("", "This binding is invalid for serve-time `pub config`: it must be an object literal or zero-argument function.");
+    }
+    return lines.join("\n");
+}
+export async function handleHover(params, session, document) {
+    const filePath = fileURLToPath(params.textDocument.uri);
+    const graph = await session.getModuleGraph(filePath);
+    if (!graph)
+        return null;
+    const mod = session.getLoadedModule(graph, filePath);
+    if (!mod)
+        return null;
+    const position = toSourcePosition(params.position, document);
+    const serveConfigMarkdown = serveConfigHoverAtPosition(graph, mod, position);
+    if (serveConfigMarkdown) {
+        return { contents: { kind: "markdown", value: serveConfigMarkdown } };
+    }
+    const markdown = hoverInfoAtPosition(graph, mod, position);
+    if (markdown) {
+        return { contents: { kind: "markdown", value: markdown } };
+    }
+    if (!document) {
+        return null;
+    }
+    const stdlibMarkdown = findStdlibHoverAtPosition(document, params.position, mod);
+    if (stdlibMarkdown) {
+        return { contents: { kind: "markdown", value: stdlibMarkdown } };
+    }
+    const typeSymbol = findTypeSymbolAtPosition(document, params.position, graph, mod);
+    if (!typeSymbol) {
+        return null;
+    }
+    return {
+        contents: {
+            kind: "markdown",
+            value: `\`\`\`rank\n${typeSymbol.name}: ${formatTypeNode(typeSymbol.type)}\n\`\`\``,
+        },
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { createConnection, ProposedFeatures, TextDocumentSyncKind, TextDocuments, } from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { fileURLToPath } from "node:url";
+import { ProjectSession } from "./session.js";
+import { publishDiagnostics } from "./features/diagnostics.js";
+import { handleHover } from "./features/hover.js";
+import { handleDefinition } from "./features/definition.js";
+import { handleCompletion } from "./features/completion.js";
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+const session = new ProjectSession();
+connection.onInitialize(() => ({
+    capabilities: {
+        textDocumentSync: TextDocumentSyncKind.Incremental,
+        hoverProvider: true,
+        definitionProvider: true,
+        completionProvider: {
+            triggerCharacters: [".", ":", " "],
+        },
+    },
+}));
+documents.onDidOpen(({ document }) => {
+    const filePath = fileURLToPath(document.uri);
+    void publishDiagnostics(connection, session, filePath);
+});
+documents.onDidChangeContent(({ document }) => {
+    const filePath = fileURLToPath(document.uri);
+    session.invalidate(filePath);
+    void publishDiagnostics(connection, session, filePath);
+});
+documents.onDidSave(({ document }) => {
+    const filePath = fileURLToPath(document.uri);
+    session.invalidate(filePath);
+    void publishDiagnostics(connection, session, filePath);
+});
+connection.onDidChangeWatchedFiles(({ changes }) => {
+    const manifestChanges = changes
+        .map(({ uri }) => fileURLToPath(uri))
+        .filter((filePath) => path.basename(filePath) === "rank.toml");
+    if (manifestChanges.length === 0) {
+        return;
+    }
+    for (const manifestPath of manifestChanges) {
+        session.invalidate(manifestPath);
+    }
+    for (const document of documents.all()) {
+        const filePath = fileURLToPath(document.uri);
+        void publishDiagnostics(connection, session, filePath);
+    }
+});
+connection.onHover((params) => handleHover(params, session, documents.get(params.textDocument.uri)));
+connection.onDefinition((params) => handleDefinition(params, session, documents.get(params.textDocument.uri)));
+connection.onCompletion((params) => handleCompletion(params, session, documents.get(params.textDocument.uri)));
+documents.listen(connection);
+connection.listen();

package/dist/session.d.ts

@@ -0,0 +1,14 @@
+import { type RootModuleGraph, type LoadedModule, type TypeCheckOptions } from "@rank-lang/compiler";
+export declare class ProjectSession {
+    private readonly cache;
+    getModuleGraph(filePath: string): Promise<RootModuleGraph | null>;
+    getLoadedModule(graph: RootModuleGraph, filePath: string): LoadedModule | null;
+    getTypeCheckOptions(filePath: string, graph?: RootModuleGraph): Promise<TypeCheckOptions | undefined>;
+    invalidate(filePath: string): void;
+    private loadGraphForFile;
+    private cacheKeyForFile;
+    private preferredEntryPathForFile;
+    private nearestTestManifestPathForFile;
+    private testManifestUsesProviderStubs;
+    private findProjectRoot;
+}

package/dist/session.js

@@ -0,0 +1,167 @@
+import path from "node:path";
+import fs from "node:fs";
+import { loadNearestRankManifestIfValid, loadProjectModuleGraphAsync, resolveSecurityOptions, } from "@rank-lang/compiler";
+// Manages a per-project-root module graph cache. The cache is invalidated on
+// textDocument/didChange and textDocument/didSave for any file in the project.
+export class ProjectSession {
+    cache = new Map();
+    async getModuleGraph(filePath) {
+        const resolvedFilePath = path.resolve(filePath);
+        const cacheKey = this.cacheKeyForFile(resolvedFilePath);
+        const cached = this.cache.get(cacheKey);
+        if (cached && !cached.invalidated && this.getLoadedModule(cached.graph, resolvedFilePath)) {
+            return cached.graph;
+        }
+        try {
+            const graph = await this.loadGraphForFile(resolvedFilePath);
+            this.cache.set(cacheKey, { graph, invalidated: false });
+            return graph;
+        }
+        catch {
+            return null;
+        }
+    }
+    getLoadedModule(graph, filePath) {
+        const resolved = path.resolve(filePath);
+        for (const mod of Object.values(graph.modules)) {
+            if (path.resolve(mod.filePath) === resolved) {
+                return mod;
+            }
+        }
+        return null;
+    }
+    async getTypeCheckOptions(filePath, graph) {
+        const resolvedFilePath = path.resolve(filePath);
+        const securityOptions = resolveSecurityOptions(loadNearestRankManifestIfValid(resolvedFilePath)?.security);
+        const testManifestPath = this.nearestTestManifestPathForFile(resolvedFilePath);
+        const providerCapabilities = new Set(securityOptions.compileTime.providerCapabilities);
+        if (testManifestPath && this.testManifestUsesProviderStubs(testManifestPath)) {
+            const loadedGraph = graph ?? await this.getModuleGraph(resolvedFilePath);
+            if (loadedGraph) {
+                for (const providerExport of Object.values(loadedGraph.providerExports)) {
+                    if (providerExport.kind !== "backend") {
+                        continue;
+                    }
+                    for (const capability of providerExport.capabilities) {
+                        providerCapabilities.add(capability);
+                    }
+                }
+            }
+        }
+        if (providerCapabilities.size === 0) {
+            if (securityOptions.compileTime.providerMutationExports.length > 0 || securityOptions.compileTime.allowedHttpHosts) {
+                return {
+                    ...(securityOptions.compileTime.providerMutationExports.length > 0
+                        ? { providerMutationExports: securityOptions.compileTime.providerMutationExports }
+                        : {}),
+                    ...(securityOptions.compileTime.allowedHttpHosts ? { allowedHttpHosts: securityOptions.compileTime.allowedHttpHosts } : {}),
+                };
+            }
+            return undefined;
+        }
+        return {
+            providerCapabilities: [...providerCapabilities].sort((left, right) => left.localeCompare(right)),
+            ...(securityOptions.compileTime.providerMutationExports.length > 0
+                ? { providerMutationExports: securityOptions.compileTime.providerMutationExports }
+                : {}),
+            ...(securityOptions.compileTime.allowedHttpHosts ? { allowedHttpHosts: securityOptions.compileTime.allowedHttpHosts } : {}),
+        };
+    }
+    invalidate(filePath) {
+        const cacheKey = this.cacheKeyForFile(filePath);
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            cached.invalidated = true;
+    }
+    async loadGraphForFile(filePath) {
+        const preferredEntryPath = this.preferredEntryPathForFile(filePath);
+        const securityOptions = resolveSecurityOptions(loadNearestRankManifestIfValid(filePath)?.security);
+        const graphOptions = securityOptions.compileTime.offline
+            ? { offline: true }
+            : undefined;
+        if (preferredEntryPath && preferredEntryPath !== filePath) {
+            const graph = await loadProjectModuleGraphAsync(preferredEntryPath, graphOptions);
+            if (this.getLoadedModule(graph, filePath)) {
+                return graph;
+            }
+        }
+        return loadProjectModuleGraphAsync(filePath, graphOptions);
+    }
+    cacheKeyForFile(filePath) {
+        return this.findProjectRoot(filePath) ?? path.resolve(filePath);
+    }
+    preferredEntryPathForFile(filePath) {
+        const resolvedFilePath = path.resolve(filePath);
+        if (path.basename(resolvedFilePath) === "main.rank") {
+            return resolvedFilePath;
+        }
+        let dir = path.dirname(resolvedFilePath);
+        const projectRoot = this.findProjectRoot(resolvedFilePath);
+        const stopDir = projectRoot ? path.resolve(projectRoot) : null;
+        for (let i = 0; i < 20; i++) {
+            const candidatePath = path.join(dir, "main.rank");
+            if (fs.existsSync(candidatePath)) {
+                return candidatePath;
+            }
+            if (stopDir && dir === stopDir) {
+                break;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir) {
+                break;
+            }
+            dir = parent;
+        }
+        return null;
+    }
+    nearestTestManifestPathForFile(filePath) {
+        let dir = path.dirname(path.resolve(filePath));
+        const projectRoot = this.findProjectRoot(filePath);
+        const stopDir = projectRoot ? path.resolve(projectRoot) : null;
+        for (let i = 0; i < 20; i++) {
+            const candidatePath = path.join(dir, "rank-test.json");
+            if (fs.existsSync(candidatePath)) {
+                return candidatePath;
+            }
+            if (stopDir && dir === stopDir) {
+                break;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir) {
+                break;
+            }
+            dir = parent;
+        }
+        return null;
+    }
+    testManifestUsesProviderStubs(manifestPath) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                return false;
+            }
+            const manifest = parsed;
+            const providerStubs = manifest.providerStubs;
+            if (manifest.kind !== "rank/test-case" || manifest.version !== 1 || typeof providerStubs !== "string" || providerStubs.length === 0) {
+                return false;
+            }
+            return fs.existsSync(path.resolve(path.dirname(manifestPath), providerStubs));
+        }
+        catch {
+            return false;
+        }
+    }
+    findProjectRoot(filePath) {
+        let dir = path.dirname(path.resolve(filePath));
+        for (let i = 0; i < 20; i++) {
+            if (fs.existsSync(path.join(dir, "rank.toml"))) {
+                return dir;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return null;
+    }
+}

package/dist/util/convert.d.ts

@@ -0,0 +1,6 @@
+import type { SourcePosition, SourceSpan, Diagnostic as CompilerDiagnostic } from "@rank-lang/compiler";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import { type Position as LspPosition, type Range as LspRange, type Diagnostic as LspDiagnostic } from "vscode-languageserver/node.js";
+export declare function toSourcePosition(pos: LspPosition, document?: TextDocument): SourcePosition;
+export declare function toLspRange(span: SourceSpan): LspRange;
+export declare function toLspDiagnostic(d: CompilerDiagnostic): LspDiagnostic;

package/dist/util/convert.js

@@ -0,0 +1,40 @@
+import { pathToFileURL } from "node:url";
+import { DiagnosticSeverity, } from "vscode-languageserver/node.js";
+// Compiler uses 1-indexed lines/columns; LSP uses 0-indexed.
+export function toSourcePosition(pos, document) {
+    return {
+        offset: document?.offsetAt(pos) ?? 0,
+        line: pos.line + 1,
+        column: pos.character + 1,
+    };
+}
+export function toLspRange(span) {
+    return {
+        start: { line: span.start.line - 1, character: span.start.column - 1 },
+        end: { line: span.end.line - 1, character: span.end.column - 1 },
+    };
+}
+export function toLspDiagnostic(d) {
+    const range = d.span
+        ? toLspRange(d.span)
+        : { start: { line: 0, character: 0 }, end: { line: 0, character: Number.MAX_SAFE_INTEGER } };
+    const diagnostic = {
+        range,
+        severity: d.severity === "error" ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning,
+        message: d.message,
+        source: "rank",
+        code: d.code,
+        ...(d.labels && d.labels.length > 0
+            ? {
+                relatedInformation: d.labels.map((label) => ({
+                    location: {
+                        uri: pathToFileURL(label.sourcePath).href,
+                        range: toLspRange(label.span),
+                    },
+                    message: label.message,
+                })),
+            }
+            : {}),
+    };
+    return diagnostic;
+}

package/dist/util/stdlib-hover.d.ts

@@ -0,0 +1,4 @@
+import { type LoadedModule } from "@rank-lang/compiler";
+import type { Position as LspPosition } from "vscode-languageserver/node.js";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+export declare function findStdlibHoverAtPosition(document: TextDocument, position: LspPosition, loadedModule: LoadedModule): string | null;