redscript-mc 2.0.0 → 2.1.1

package/dist/src/lsp/server.js

@@ -0,0 +1,403 @@
+"use strict";
+/**
+ * RedScript Language Server
+ *
+ * Implements LSP (Language Server Protocol) over stdio.
+ * Features:
+ *   - Diagnostics (type errors, parse errors)
+ *   - Hover (type information)
+ *   - Go-to-definition (functions, variables)
+ *   - Completion (keywords, functions, builtins)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = require("vscode-languageserver/node");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const typechecker_1 = require("../typechecker");
+const diagnostics_1 = require("../diagnostics");
+const metadata_1 = require("../builtins/metadata");
+// ---------------------------------------------------------------------------
+// Connection and document manager
+// ---------------------------------------------------------------------------
+const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
+const parsedDocs = new Map();
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function typeToString(t) {
+    switch (t.kind) {
+        case 'named': return t.name;
+        case 'array': return `${typeToString(t.elem)}[]`;
+        case 'struct': return t.name;
+        case 'enum': return t.name;
+        case 'entity': return t.entityType;
+        case 'selector': return t.entityType ? `selector<${t.entityType}>` : 'selector';
+        case 'tuple': return `(${t.elements.map(typeToString).join(', ')})`;
+        case 'function_type':
+            return `(${t.params.map(typeToString).join(', ')}) => ${typeToString(t.return)}`;
+        default:
+            return 'unknown';
+    }
+}
+/** Parse and type-check a document, caching the result. */
+function parseDocument(uri, source) {
+    const errors = [];
+    let program = null;
+    try {
+        const lexer = new lexer_1.Lexer(source);
+        const tokens = lexer.tokenize();
+        const parser = new parser_1.Parser(tokens, source, uri);
+        program = parser.parse('redscript');
+        // Type-check (warn mode — collects errors but doesn't throw)
+        const checker = new typechecker_1.TypeChecker(source, uri);
+        const typeErrors = checker.check(program);
+        errors.push(...typeErrors);
+    }
+    catch (err) {
+        if (err instanceof diagnostics_1.DiagnosticError) {
+            errors.push(err);
+        }
+        else if (err instanceof Error) {
+            // Wrap parse errors that aren't DiagnosticError
+            errors.push(new diagnostics_1.DiagnosticError('ParseError', err.message, { line: 1, col: 1, file: uri }));
+        }
+    }
+    const doc = { program, errors, source };
+    parsedDocs.set(uri, doc);
+    return doc;
+}
+/** Convert a DiagnosticError to an LSP Diagnostic. */
+function toDiagnostic(err) {
+    const line = Math.max(0, (err.location?.line ?? 1) - 1);
+    const col = Math.max(0, (err.location?.col ?? 1) - 1);
+    return {
+        severity: node_1.DiagnosticSeverity.Error,
+        range: {
+            start: { line, character: col },
+            end: { line, character: col + 80 },
+        },
+        message: err.message,
+        source: 'redscript',
+    };
+}
+// ---------------------------------------------------------------------------
+// Decorator hover docs
+// ---------------------------------------------------------------------------
+const DECORATOR_DOCS = {
+    tick: 'Runs every MC game tick (~20 Hz). No arguments.',
+    load: 'Runs on `/reload`. Use for initialization logic.',
+    coroutine: 'Splits loops into tick-spread continuations. Arg: `batch=N` (steps per tick, default 1).',
+    schedule: 'Schedules the function to run after N ticks. Arg: `ticks=N`.',
+    on_trigger: 'Runs when a trigger scoreboard objective is set by a player. Arg: trigger name.',
+    keep: 'Prevents the compiler from dead-code-eliminating this function.',
+    on: 'Generic event handler decorator.',
+    on_advancement: 'Runs when a player earns an advancement. Arg: advancement id.',
+    on_craft: 'Runs when a player crafts an item. Arg: item id.',
+    on_death: 'Runs when a player dies.',
+    on_join_team: 'Runs when a player joins a team. Arg: team name.',
+    on_login: 'Runs when a player logs in.',
+};
+// ---------------------------------------------------------------------------
+// Hover helpers
+// ---------------------------------------------------------------------------
+/** Find the word at a position in a text. */
+function wordAt(source, position) {
+    const lines = source.split('\n');
+    const line = lines[position.line] ?? '';
+    const ch = position.character;
+    // Expand left
+    let start = ch;
+    while (start > 0 && /\w/.test(line[start - 1]))
+        start--;
+    // Expand right
+    let end = ch;
+    while (end < line.length && /\w/.test(line[end]))
+        end++;
+    return line.slice(start, end);
+}
+/** Find a function declaration by name in a parsed program. */
+function findFunction(program, name) {
+    // Top-level functions
+    const fn = program.declarations.find(f => f.name === name);
+    if (fn)
+        return fn;
+    // Impl methods
+    for (const impl of program.implBlocks ?? []) {
+        const m = impl.methods.find(f => f.name === name);
+        if (m)
+            return m;
+    }
+    return undefined;
+}
+/** Format a function signature for hover. */
+function formatFnSignature(fn) {
+    const params = fn.params.map(p => `${p.name}: ${typeToString(p.type)}`).join(', ');
+    const ret = typeToString(fn.returnType);
+    const typeParams = fn.typeParams?.length ? `<${fn.typeParams.join(', ')}>` : '';
+    return `fn ${fn.name}${typeParams}(${params}): ${ret}`;
+}
+// ---------------------------------------------------------------------------
+// Go-to-definition helpers
+// ---------------------------------------------------------------------------
+/** Build a mapping from identifier name → definition location. */
+function buildDefinitionMap(program, source) {
+    const map = new Map();
+    for (const fn of program.declarations) {
+        if (fn.span)
+            map.set(fn.name, fn.span);
+    }
+    for (const impl of program.implBlocks ?? []) {
+        for (const m of impl.methods) {
+            if (m.span)
+                map.set(`${impl.typeName}.${m.name}`, m.span);
+        }
+    }
+    for (const s of program.structs ?? []) {
+        if (s.span)
+            map.set(s.name, s.span);
+    }
+    for (const e of program.enums ?? []) {
+        if (e.span)
+            map.set(e.name, e.span);
+    }
+    for (const c of program.consts ?? []) {
+        if (c.span)
+            map.set(c.name, c.span);
+    }
+    for (const g of program.globals ?? []) {
+        if (g.span)
+            map.set(g.name, g.span);
+    }
+    return map;
+}
+// ---------------------------------------------------------------------------
+// Completion items
+// ---------------------------------------------------------------------------
+const KEYWORD_COMPLETIONS = [
+    'fn', 'let', 'if', 'else', 'while', 'for', 'foreach', 'return',
+    'break', 'continue', 'as', 'at', 'match', 'struct', 'enum', 'impl',
+    'const', 'global', 'true', 'false', 'module', 'import',
+].map(kw => ({
+    label: kw,
+    kind: node_1.CompletionItemKind.Keyword,
+}));
+const TYPE_COMPLETIONS = [
+    'int', 'bool', 'float', 'string', 'void', 'BlockPos', 'byte', 'short', 'long', 'double',
+    'entity', 'Player', 'Mob', 'HostileMob', 'PassiveMob',
+    'Zombie', 'Skeleton', 'Creeper', 'Spider', 'Enderman',
+].map(t => ({
+    label: t,
+    kind: node_1.CompletionItemKind.TypeParameter,
+}));
+const DECORATOR_COMPLETIONS = [
+    '@tick', '@load', '@on', '@coroutine', '@keep',
+].map(d => ({
+    label: d,
+    kind: node_1.CompletionItemKind.Event,
+}));
+const BUILTIN_FN_COMPLETIONS = [
+    'say', 'tell', 'give', 'kill', 'teleport', 'summon', 'setblock',
+    'fill', 'clone', 'effect', 'enchant', 'experience', 'gamemode',
+    'gamerule', 'particle', 'playsound', 'stopsound', 'scoreboard',
+    'tag', 'title', 'subtitle', 'actionbar', 'tellraw', 'announce',
+    'setTimeout', 'setInterval', 'clearInterval',
+].map(fn => ({
+    label: fn,
+    kind: node_1.CompletionItemKind.Function,
+}));
+// ---------------------------------------------------------------------------
+// Server lifecycle
+// ---------------------------------------------------------------------------
+connection.onInitialize((_params) => {
+    return {
+        capabilities: {
+            textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
+            hoverProvider: true,
+            definitionProvider: true,
+            completionProvider: {
+                triggerCharacters: ['.', '@'],
+                resolveProvider: false,
+            },
+        },
+        serverInfo: {
+            name: 'redscript-lsp',
+            version: '1.0.0',
+        },
+    };
+});
+connection.onInitialized(() => {
+    connection.console.log('RedScript LSP server ready');
+});
+// ---------------------------------------------------------------------------
+// Document sync → diagnostics
+// ---------------------------------------------------------------------------
+function validateAndPublish(doc) {
+    const source = doc.getText();
+    const parsed = parseDocument(doc.uri, source);
+    const diagnostics = parsed.errors.map(toDiagnostic);
+    connection.sendDiagnostics({ uri: doc.uri, diagnostics });
+}
+documents.onDidOpen(e => validateAndPublish(e.document));
+documents.onDidChangeContent(e => validateAndPublish(e.document));
+documents.onDidClose(e => {
+    parsedDocs.delete(e.document.uri);
+    connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] });
+});
+// ---------------------------------------------------------------------------
+// Hover
+// ---------------------------------------------------------------------------
+connection.onHover((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc)
+        return null;
+    const source = doc.getText();
+    const cached = parsedDocs.get(params.textDocument.uri);
+    const program = cached?.program ?? null;
+    if (!program)
+        return null;
+    // Check if cursor is on a decorator (@tick, @load, etc.)
+    const lines = source.split('\n');
+    const lineText = lines[params.position.line] ?? '';
+    const decoratorMatch = lineText.match(/@([a-zA-Z_][a-zA-Z0-9_]*)/);
+    if (decoratorMatch) {
+        const ch = params.position.character;
+        const atIdx = lineText.indexOf('@');
+        const decoratorEnd = atIdx + 1 + decoratorMatch[1].length;
+        if (ch >= atIdx && ch <= decoratorEnd) {
+            const decoratorName = decoratorMatch[1];
+            const decoratorDoc = DECORATOR_DOCS[decoratorName];
+            if (decoratorDoc) {
+                const content = {
+                    kind: node_1.MarkupKind.Markdown,
+                    value: `**@${decoratorName}** — ${decoratorDoc}`,
+                };
+                return { contents: content };
+            }
+        }
+    }
+    const word = wordAt(source, params.position);
+    if (!word)
+        return null;
+    // Check builtins
+    const builtin = metadata_1.BUILTIN_METADATA[word];
+    if (builtin) {
+        const paramStr = builtin.params
+            .map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`)
+            .join(', ');
+        const sig = `fn ${builtin.name}(${paramStr}): ${builtin.returns}`;
+        const content = {
+            kind: node_1.MarkupKind.Markdown,
+            value: `\`\`\`redscript\n${sig}\n\`\`\`\n${builtin.doc}`,
+        };
+        return { contents: content };
+    }
+    // Check if it's a known function
+    const fn = findFunction(program, word);
+    if (fn) {
+        const sig = formatFnSignature(fn);
+        const content = {
+            kind: node_1.MarkupKind.Markdown,
+            value: `\`\`\`redscript\n${sig}\n\`\`\``,
+        };
+        return { contents: content };
+    }
+    // Check structs
+    const struct = program.structs?.find(s => s.name === word);
+    if (struct) {
+        const fields = struct.fields.map(f => `  ${f.name}: ${typeToString(f.type)}`).join('\n');
+        const content = {
+            kind: node_1.MarkupKind.Markdown,
+            value: `\`\`\`redscript\nstruct ${struct.name} {\n${fields}\n}\n\`\`\``,
+        };
+        return { contents: content };
+    }
+    // Check enums
+    const enumDecl = program.enums?.find(e => e.name === word);
+    if (enumDecl) {
+        const variants = enumDecl.variants.map(v => `  ${v.name}`).join('\n');
+        const content = {
+            kind: node_1.MarkupKind.Markdown,
+            value: `\`\`\`redscript\nenum ${enumDecl.name} {\n${variants}\n}\n\`\`\``,
+        };
+        return { contents: content };
+    }
+    // Check consts
+    const constDecl = program.consts?.find(c => c.name === word);
+    if (constDecl) {
+        const content = {
+            kind: node_1.MarkupKind.Markdown,
+            value: `\`\`\`redscript\nconst ${constDecl.name}: ${typeToString(constDecl.type)}\n\`\`\``,
+        };
+        return { contents: content };
+    }
+    return null;
+});
+// ---------------------------------------------------------------------------
+// Go-to-definition
+// ---------------------------------------------------------------------------
+connection.onDefinition((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc)
+        return null;
+    const source = doc.getText();
+    const cached = parsedDocs.get(params.textDocument.uri);
+    const program = cached?.program ?? null;
+    if (!program)
+        return null;
+    const word = wordAt(source, params.position);
+    if (!word)
+        return null;
+    const defMap = buildDefinitionMap(program, source);
+    const span = defMap.get(word);
+    if (!span)
+        return null;
+    const line = Math.max(0, span.line - 1);
+    const col = Math.max(0, span.col - 1);
+    return {
+        uri: params.textDocument.uri,
+        range: {
+            start: { line, character: col },
+            end: { line, character: col + word.length },
+        },
+    };
+});
+// ---------------------------------------------------------------------------
+// Completion
+// ---------------------------------------------------------------------------
+connection.onCompletion((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    const items = [
+        ...KEYWORD_COMPLETIONS,
+        ...TYPE_COMPLETIONS,
+        ...BUILTIN_FN_COMPLETIONS,
+        ...DECORATOR_COMPLETIONS,
+    ];
+    if (!doc)
+        return items;
+    // Add user-defined functions from the parsed doc
+    const cached = parsedDocs.get(params.textDocument.uri);
+    const program = cached?.program ?? null;
+    if (program) {
+        for (const fn of program.declarations) {
+            items.push({ label: fn.name, kind: node_1.CompletionItemKind.Function });
+        }
+        for (const s of program.structs ?? []) {
+            items.push({ label: s.name, kind: node_1.CompletionItemKind.Struct });
+        }
+        for (const e of program.enums ?? []) {
+            items.push({ label: e.name, kind: node_1.CompletionItemKind.Enum });
+        }
+        for (const c of program.consts ?? []) {
+            items.push({ label: c.name, kind: node_1.CompletionItemKind.Constant });
+        }
+    }
+    return items;
+});
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+documents.listen(connection);
+connection.listen();
+//# sourceMappingURL=server.js.map

package/dist/{src2 → src}/mir/lower.d.ts

@@ -6,4 +6,4 @@
  */
 import type { HIRModule } from '../hir/types';
 import type { MIRModule } from './types';
-export declare function lowerToMIR(hir: HIRModule): MIRModule;
+export declare function lowerToMIR(hir: HIRModule, sourceFile?: string): MIRModule;