@crowdedkingdoms/crowdyjs 8.22.0 → 9.0.0

package/dist/live-coding/rust-analysis.js

@@ -0,0 +1,312 @@
+import { Language, Parser, } from 'web-tree-sitter';
+import { offsetAt } from './vfs.js';
+const DECLARATION_KINDS = new Map([
+    ['function_item', 12],
+    ['function_signature_item', 12],
+    ['struct_item', 23],
+    ['enum_item', 10],
+    ['trait_item', 11],
+    ['type_item', 5],
+    ['const_item', 14],
+    ['static_item', 13],
+    ['mod_item', 2],
+    ['macro_definition', 12],
+]);
+const RUST_KEYWORDS = [
+    'as',
+    'async',
+    'await',
+    'break',
+    'const',
+    'continue',
+    'crate',
+    'dyn',
+    'else',
+    'enum',
+    'extern',
+    'false',
+    'fn',
+    'for',
+    'if',
+    'impl',
+    'in',
+    'let',
+    'loop',
+    'match',
+    'mod',
+    'move',
+    'mut',
+    'pub',
+    'ref',
+    'return',
+    'self',
+    'static',
+    'struct',
+    'super',
+    'trait',
+    'true',
+    'type',
+    'unsafe',
+    'use',
+    'where',
+    'while',
+];
+let parserInitialization = null;
+export class RustAnalysis {
+    constructor(parser, platformIndex) {
+        this.parser = parser;
+        this.platformIndex = platformIndex;
+        this.cache = new Map();
+    }
+    static async create(options) {
+        parserInitialization ?? (parserInitialization = Parser.init({
+            locateFile: () => options.parserWasmUrl,
+        }));
+        await parserInitialization;
+        const language = await Language.load(options.grammarWasmUrl);
+        const parser = new Parser();
+        parser.setLanguage(language);
+        return new RustAnalysis(parser, options.platformIndex);
+    }
+    diagnostics(document) {
+        return this.analyze(document).diagnostics;
+    }
+    completions(document, position, workspace) {
+        const prefix = wordPrefixAt(document.text, position);
+        const local = this.workspaceSymbols(workspace);
+        const items = [];
+        const seen = new Set();
+        const add = (item) => {
+            if (seen.has(item.label) ||
+                (prefix && !item.label.toLowerCase().startsWith(prefix.toLowerCase()))) {
+                return;
+            }
+            seen.add(item.label);
+            items.push(item);
+        };
+        for (const symbol of local) {
+            add({
+                label: symbol.name,
+                kind: symbol.kind,
+                detail: symbol.detail,
+                sortText: `0-${symbol.name}`,
+            });
+        }
+        for (const symbol of this.platformIndex.symbols) {
+            add(platformCompletion(symbol, this.platformIndex));
+        }
+        for (const keyword of RUST_KEYWORDS) {
+            add({ label: keyword, kind: 14, detail: 'Rust keyword', sortText: `2-${keyword}` });
+        }
+        return items.slice(0, 200);
+    }
+    hover(document, position, workspace) {
+        const word = wordAt(document.text, position);
+        if (!word)
+            return null;
+        const local = this.workspaceSymbols(workspace).find((symbol) => symbol.name === word);
+        if (local) {
+            return {
+                contents: {
+                    kind: 'markdown',
+                    value: `\`\`\`rust\n${local.detail}\n\`\`\`\n\nDefined in \`${local.uri}\`.`,
+                },
+                range: wordRange(document.text, position),
+            };
+        }
+        const platform = this.platformIndex.symbols.find((symbol) => symbol.name.replace(/!$/u, '').split('::').at(-1) === word);
+        if (!platform)
+            return null;
+        const crate = platformCrateForSymbol(this.platformIndex, platform);
+        const provenance = crate
+            ? `Crate ${crate.name} ${crate.version} · source ${crate.sourceHash.slice(0, 12)}…\n\n`
+            : '';
+        return {
+            contents: {
+                kind: 'markdown',
+                value: `\`\`\`rust\n${platform.signature}\n\`\`\`\n\n` +
+                    `${platform.docs || `Defined in \`${platform.module}\`.`}\n\n` +
+                    provenance +
+                    `SDK ${this.platformIndex.sdkVersion} · ABI ${this.platformIndex.abiVersion}`,
+            },
+            range: wordRange(document.text, position),
+        };
+    }
+    documentSymbols(document) {
+        return this.analyze(document).symbols.map((symbol) => ({
+            name: symbol.name,
+            detail: symbol.detail,
+            kind: symbol.kind,
+            range: symbol.range,
+            selectionRange: symbol.selectionRange,
+        }));
+    }
+    definition(document, position, workspace) {
+        const word = wordAt(document.text, position);
+        if (!word)
+            return null;
+        const symbol = this.workspaceSymbols(workspace).find((candidate) => candidate.name === word);
+        return symbol
+            ? { uri: symbol.uri, range: symbol.selectionRange }
+            : null;
+    }
+    invalidate(uri) {
+        this.cache.delete(uri);
+    }
+    dispose() {
+        this.cache.clear();
+        this.parser.delete();
+    }
+    workspaceSymbols(documents) {
+        return documents.flatMap((document) => this.analyze(document).symbols);
+    }
+    analyze(document) {
+        const cached = this.cache.get(document.uri);
+        if (cached?.version === document.version)
+            return cached;
+        const tree = this.parser.parse(document.text);
+        if (!tree)
+            throw new Error(`Rust parser did not produce a tree for ${document.path}`);
+        try {
+            const diagnostics = [];
+            const symbols = [];
+            visit(tree.rootNode, (node) => {
+                if ((node.isError || node.isMissing) && diagnostics.length < 100) {
+                    diagnostics.push({
+                        range: nodeRange(document.text, node),
+                        severity: 1,
+                        source: 'crowdy-rust',
+                        code: node.isMissing ? 'missing-syntax' : 'syntax-error',
+                        message: node.isMissing
+                            ? `Expected ${node.type}`
+                            : `Unexpected Rust syntax: ${bounded(node.text, 80) || node.type}`,
+                    });
+                }
+                const kind = DECLARATION_KINDS.get(node.type);
+                if (kind === undefined)
+                    return;
+                const nameNode = node.childForFieldName('name') ??
+                    node.namedChildren.find((child) => child.type === 'identifier');
+                if (!nameNode)
+                    return;
+                const name = nameNode.text.replace(/!$/u, '');
+                symbols.push({
+                    name,
+                    detail: declarationDetail(node),
+                    kind: node.type === 'function_item' && node.parent?.type === 'declaration_list'
+                        ? 6
+                        : kind,
+                    uri: document.uri,
+                    range: nodeRange(document.text, node),
+                    selectionRange: nodeRange(document.text, nameNode),
+                });
+            });
+            const result = { version: document.version, diagnostics, symbols };
+            this.cache.set(document.uri, result);
+            return result;
+        }
+        finally {
+            tree.delete();
+        }
+    }
+}
+function visit(node, callback) {
+    callback(node);
+    for (const child of node.namedChildren)
+        visit(child, callback);
+}
+function declarationDetail(node) {
+    const firstBody = node.text.search(/[;{]/u);
+    return bounded((firstBody < 0 ? node.text : node.text.slice(0, firstBody)).trim(), 500);
+}
+function nodeRange(text, node) {
+    return {
+        start: pointToPosition(text, node.startPosition),
+        end: pointToPosition(text, node.endPosition),
+    };
+}
+function pointToPosition(text, point) {
+    const lines = text.split('\n');
+    const line = lines[point.row] ?? '';
+    let bytes = 0;
+    let character = 0;
+    for (const value of line) {
+        const width = new TextEncoder().encode(value).byteLength;
+        if (bytes + width > point.column)
+            break;
+        bytes += width;
+        character += value.length;
+    }
+    return { line: point.row, character };
+}
+function wordAt(text, position) {
+    const offset = offsetAt(text, position);
+    const left = text.slice(0, offset).match(/[A-Za-z_][A-Za-z0-9_]*$/u)?.[0] ?? '';
+    const right = text.slice(offset).match(/^[A-Za-z0-9_]*/u)?.[0] ?? '';
+    const word = left + right;
+    return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(word) ? word : null;
+}
+function wordPrefixAt(text, position) {
+    const offset = offsetAt(text, position);
+    return text.slice(0, offset).match(/[A-Za-z_][A-Za-z0-9_]*$/u)?.[0] ?? '';
+}
+function wordRange(text, position) {
+    const offset = offsetAt(text, position);
+    const left = text.slice(0, offset).match(/[A-Za-z_][A-Za-z0-9_]*$/u)?.[0] ?? '';
+    const right = text.slice(offset).match(/^[A-Za-z0-9_]*/u)?.[0] ?? '';
+    return {
+        start: { line: position.line, character: position.character - left.length },
+        end: { line: position.line, character: position.character + right.length },
+    };
+}
+function platformCompletion(symbol, index) {
+    const crate = platformCrateForSymbol(index, symbol);
+    const label = symbol.kind === 'field'
+        ? symbol.name.split('::').at(-1)
+        : symbol.kind === 'macro' && !symbol.name.endsWith('!')
+            ? `${symbol.name}!`
+            : symbol.name;
+    return {
+        label,
+        kind: platformCompletionKind(symbol.kind),
+        detail: `${symbol.module} · ${symbol.signature}` +
+            (crate ? ` · ${crate.name}@${crate.version}` : ''),
+        documentation: symbol.docs,
+        insertText: label,
+        sortText: `1-${label}`,
+    };
+}
+function platformCompletionKind(kind) {
+    switch (kind) {
+        case 'function':
+        case 'method':
+            return 3;
+        case 'macro':
+            return 15;
+        case 'module':
+            return 9;
+        case 'const':
+            return 21;
+        case 'static':
+            return 6;
+        case 'field':
+            return 5;
+        case 'enum':
+            return 13;
+        case 'variant':
+            return 20;
+        case 'reexport':
+            return 9;
+        case 'struct':
+        case 'trait':
+        case 'type':
+            return 7;
+    }
+}
+function platformCrateForSymbol(index, symbol) {
+    const moduleRoot = symbol.module.split('::', 1)[0];
+    return index.crates.find((crate) => crate.name.replace(/-/gu, '_') === moduleRoot);
+}
+function bounded(value, length) {
+    return value.length <= length ? value : `${value.slice(0, length - 1)}…`;
+}

package/dist/live-coding/rust-lsp-server.d.ts

@@ -0,0 +1,43 @@
+import { type PlatformIndex } from './platform-index.js';
+import { RustAnalysis } from './rust-analysis.js';
+export interface RustLspServerOptions {
+    postMessage: (message: unknown) => void;
+    createAnalysis: (index: PlatformIndex) => Promise<RustAnalysis>;
+    diagnosticDebounceMs?: number;
+    requestTimeoutMs?: number;
+}
+export declare const MAX_PENDING_LSP_REQUESTS = 256;
+export declare class RustLspServer {
+    private readonly options;
+    private vfs;
+    private analysis;
+    private initialized;
+    private shuttingDown;
+    private disposed;
+    private readonly requestStates;
+    private readonly diagnosticTimers;
+    private readonly diagnosticGenerations;
+    constructor(options: RustLspServerOptions);
+    handle(raw: unknown): Promise<void>;
+    /**
+     * Observes a worker message before it enters the serialized dispatch queue.
+     * Request state is bounded, and unknown cancellation ids are never retained.
+     */
+    observeIncoming(raw: unknown): boolean;
+    /** Backwards-compatible immediate cancellation hook for direct transports. */
+    handleImmediate(raw: unknown): boolean;
+    private cancelRequest;
+    dispose(): void;
+    private handleRequest;
+    private initialize;
+    private dispatchAnalysisRequest;
+    private handleNotification;
+    private scheduleDiagnostics;
+    private cancelDiagnostics;
+    private publishDiagnostics;
+    private requireVfs;
+    private requireAnalysis;
+    private sendResult;
+    private sendError;
+}
+//# sourceMappingURL=rust-lsp-server.d.ts.map

package/dist/live-coding/rust-lsp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-lsp-server.d.ts","sourceRoot":"","sources":["../../src/live-coding/rust-lsp-server.ts"],"names":[],"mappings":"AAUA,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAQlD,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,cAAc,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAChE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAiBD,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,qBAAa,aAAa;IAaZ,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZpC,OAAO,CAAC,GAAG,CAAkC;IAC7C,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAG1B;IACJ,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoD;IACrF,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAA6B;gBAEtC,OAAO,EAAE,oBAAoB;IAEpD,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBzC;;;OAGG;IACH,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IA8BtC,8EAA8E;IAC9E,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAItC,OAAO,CAAC,aAAa;IAQrB,OAAO,IAAI,IAAI;YAgBD,aAAa;YA8Eb,UAAU;YAwCV,uBAAuB;YAgEvB,kBAAkB;IAwFhC,OAAO,CAAC,mBAAmB;IAyB3B,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,SAAS;CAYlB"}