redscript-mc 1.2.30 → 2.1.0

package/dist/src/lir/verify.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * LIR Verifier — validates structural invariants of LIR modules.
+ *
+ * Checks:
+ * 1. All Slots use the module's objective
+ * 2. No undefined function references (call/call_if_* targets exist)
+ * 3. macro_line only appears in isMacro functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyLIR = verifyLIR;
+function verifyLIR(module) {
+    const errors = [];
+    const fnNames = new Set(module.functions.map(f => `${module.namespace}:${f.name}`));
+    for (const fn of module.functions) {
+        errors.push(...verifyFunction(fn, module, fnNames));
+    }
+    return errors;
+}
+function verifyFunction(fn, module, fnNames) {
+    const errors = [];
+    for (const instr of fn.instructions) {
+        // Check objective on all slots
+        for (const slot of getSlotsFromInstr(instr)) {
+            if (slot.obj !== module.objective) {
+                errors.push({
+                    fn: fn.name,
+                    message: `slot '${slot.player}' uses objective '${slot.obj}' but module objective is '${module.objective}'`,
+                });
+            }
+        }
+        // Check function references
+        for (const ref of getFnRefsFromInstr(instr)) {
+            // Skip empty refs (used in store_cmd_to_score with cmp pattern)
+            if (ref === '' || ref === `${module.namespace}:`)
+                continue;
+            if (!fnNames.has(ref)) {
+                errors.push({
+                    fn: fn.name,
+                    message: `references undefined function '${ref}'`,
+                });
+            }
+        }
+        // Check macro_line only in macro functions
+        if (instr.kind === 'macro_line' && !fn.isMacro) {
+            errors.push({
+                fn: fn.name,
+                message: `macro_line instruction in non-macro function`,
+            });
+        }
+    }
+    return errors;
+}
+function getSlotsFromInstr(instr) {
+    switch (instr.kind) {
+        case 'score_set':
+            return [instr.dst];
+        case 'score_copy':
+        case 'score_add':
+        case 'score_sub':
+        case 'score_mul':
+        case 'score_div':
+        case 'score_mod':
+        case 'score_min':
+        case 'score_max':
+            return [instr.dst, instr.src];
+        case 'score_swap':
+            return [instr.a, instr.b];
+        case 'store_cmd_to_score':
+            return [instr.dst, ...getSlotsFromInstr(instr.cmd)];
+        case 'store_score_to_nbt':
+            return [instr.src];
+        case 'store_nbt_to_score':
+            return [instr.dst];
+        case 'call_if_matches':
+        case 'call_unless_matches':
+            return [instr.slot];
+        case 'call_if_score':
+        case 'call_unless_score':
+            return [instr.a, instr.b];
+        case 'return_value':
+            return [instr.slot];
+        case 'call':
+        case 'call_macro':
+        case 'call_context':
+        case 'nbt_set_literal':
+        case 'nbt_copy':
+        case 'macro_line':
+        case 'raw':
+            return [];
+    }
+}
+function getFnRefsFromInstr(instr) {
+    switch (instr.kind) {
+        case 'call':
+            return [instr.fn];
+        case 'call_macro':
+            return [instr.fn];
+        case 'call_if_matches':
+        case 'call_unless_matches':
+            return [instr.fn];
+        case 'call_if_score':
+        case 'call_unless_score':
+            return [instr.fn];
+        case 'call_context':
+            return [instr.fn];
+        case 'store_cmd_to_score':
+            return getFnRefsFromInstr(instr.cmd);
+        default:
+            return [];
+    }
+}
+//# sourceMappingURL=verify.js.map

package/dist/src/lsp/main.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * RedScript LSP server entry point.
+ * Communicates over stdio (standard LSP protocol).
+ *
+ * Usage: redscript-lsp  (started by your editor's LSP client)
+ */
+import './server';

package/dist/src/lsp/main.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * RedScript LSP server entry point.
+ * Communicates over stdio (standard LSP protocol).
+ *
+ * Usage: redscript-lsp  (started by your editor's LSP client)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./server");
+//# sourceMappingURL=main.js.map

package/dist/src/lsp/server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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)
+ */
+export {};

package/dist/src/lsp/server.js

@@ -0,0 +1,352 @@
+"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");
+// ---------------------------------------------------------------------------
+// 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',
+    };
+}
+// ---------------------------------------------------------------------------
+// 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;
+    const word = wordAt(source, params.position);
+    if (!word)
+        return null;
+    // 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/{mc-test → src/mc-test}/runner.js

@@ -68,9 +68,10 @@ async function runMCTests(sourceFile, tests, options = {}) {
         // Compile and install datapack
         const outDir = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
         console.log(`Compiling ${sourceFile}...`);
-        const result = (0, compile_1.compile)(fs.readFileSync(sourceFile, 'utf-8'));
-        if (!result.success || !result.files) {
-            throw result.error ?? new Error('Compilation failed');
+        const ns = path.basename(sourceFile, '.mcrs');
+        const result = (0, compile_1.compile)(fs.readFileSync(sourceFile, 'utf-8'), { namespace: ns, filePath: sourceFile });
+        if (!result.files) {
+            throw new Error('Compilation failed');
         }
         // Write files
         fs.mkdirSync(outDir, { recursive: true });

package/dist/src/mir/lower.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HIR → MIR Lowering — Stage 3 of the RedScript compiler pipeline.
+ *
+ * Converts structured HIR (if/while/break/continue) into an explicit CFG
+ * with 3-address instructions and unlimited fresh temporaries.
+ */
+import type { HIRModule } from '../hir/types';
+import type { MIRModule } from './types';
+export declare function lowerToMIR(hir: HIRModule, sourceFile?: string): MIRModule;