redscript-mc 2.6.2 → 3.0.0

package/dist/src/lir/lower.js

@@ -95,6 +95,7 @@ class LoweringContext {
             instructions: [macroLine],
             isMacro: true,
             macroParams: ['arr_idx'],
+            sourceSnippet: `dynamic index helper for ${ns} ${pathPrefix}`,
         });
         this.dynIdxHelpers.set(key, qualifiedName);
         return qualifiedName;
@@ -124,6 +125,7 @@ class LoweringContext {
             instructions: [macroLine],
             isMacro: true,
             macroParams: ['arr_idx', 'arr_val'],
+            sourceSnippet: `dynamic write helper for ${ns} ${pathPrefix}`,
         });
         this.dynWrtHelpers.set(key, qualifiedName);
         return qualifiedName;
@@ -197,6 +199,8 @@ function lowerFunction(fn, ctx) {
         instructions: instrs,
         isMacro: fn.isMacro,
         macroParams: fn.params.filter(p => p.isMacroParam).map(p => p.name),
+        sourceLoc: fn.sourceLoc,
+        sourceSnippet: fn.sourceSnippet,
     });
     // Emit separate functions for multi-pred blocks
     for (const blockId of ctx['multiPredBlocks']) {
@@ -209,6 +213,8 @@ function lowerFunction(fn, ctx) {
                 instructions: blockInstrs,
                 isMacro: false,
                 macroParams: [],
+                sourceLoc: fn.sourceLoc,
+                sourceSnippet: fn.sourceSnippet,
             });
         }
     }
@@ -291,6 +297,17 @@ function lowerInstrInner(instr, fn, ctx, instrs) {
             });
             break;
         }
+        case 'string_match': {
+            const dst = ctx.slot(instr.dst);
+            const dstStr = `${dst.player} ${dst.obj}`;
+            const literal = JSON.stringify(instr.value);
+            instrs.push({ kind: 'score_set', dst, value: 0 });
+            instrs.push({
+                kind: 'raw',
+                cmd: `execute if data storage ${instr.ns} ${instr.path} matches ${literal} run scoreboard players set ${dstStr} 1`,
+            });
+            break;
+        }
         case 'and': {
             // Bitwise/logical AND: both are 0/1, so multiply works
             // But more accurately: dst = (a != 0) && (b != 0)
@@ -331,9 +348,15 @@ function lowerInstrInner(instr, fn, ctx, instrs) {
         }
         case 'nbt_list_len': {
             // emit: execute store result score $dst_name __ns run data get storage ns path
+            // MC: `data get storage ns path` on an NBT list returns the element count
             const dst = ctx.slot(instr.dst);
-            const ns = ctx.namespace;
-            instrs.push({ kind: 'raw', cmd: `execute store result score ${dst} __${ns} run data get storage ${instr.ns} ${instr.path}` });
+            instrs.push({
+                kind: 'store_nbt_to_score',
+                dst,
+                ns: instr.ns,
+                path: instr.path,
+                scale: 1,
+            });
             break;
         }
         case 'nbt_read_dynamic': {
@@ -563,6 +586,8 @@ function emitBranchTarget(blockId, fn, ctx, parentVisited) {
                 instructions: blockInstrs,
                 isMacro: false,
                 macroParams: [],
+                sourceLoc: fn.sourceLoc,
+                sourceSnippet: fn.sourceSnippet,
             });
             parentVisited.add(blockId);
         }
@@ -578,6 +603,8 @@ function emitBranchTarget(blockId, fn, ctx, parentVisited) {
         instructions: blockInstrs,
         isMacro: false,
         macroParams: [],
+        sourceLoc: fn.sourceLoc,
+        sourceSnippet: fn.sourceSnippet,
     });
     // Mark visited so parent doesn't re-inline
     parentVisited.add(blockId);

package/dist/src/lir/types.d.ts

@@ -131,6 +131,8 @@ export interface LIRFunction {
     instructions: LIRInstr[];
     isMacro: boolean;
     macroParams: string[];
+    sourceLoc?: SourceLoc;
+    sourceSnippet?: string;
 }
 export interface LIRModule {
     functions: LIRFunction[];

package/dist/src/lsp/server.js

@@ -53,6 +53,7 @@ const parser_1 = require("../parser");
 const typechecker_1 = require("../typechecker");
 const diagnostics_1 = require("../diagnostics");
 const metadata_1 = require("../builtins/metadata");
+const lint_1 = require("../lint");
 // ---------------------------------------------------------------------------
 // Connection and document manager
 // ---------------------------------------------------------------------------
@@ -209,12 +210,37 @@ function toDiagnostic(err) {
         source: 'redscript',
     };
 }
+/** Severity mapping for lint rules. */
+const LINT_SEVERITY_MAP = {
+    'unused-variable': node_1.DiagnosticSeverity.Information,
+    'magic-number': node_1.DiagnosticSeverity.Hint,
+    'dead-branch': node_1.DiagnosticSeverity.Warning,
+    'unused-import': node_1.DiagnosticSeverity.Information,
+    'function-too-long': node_1.DiagnosticSeverity.Warning,
+};
+/** Convert a LintWarning to an LSP Diagnostic. */
+function lintWarningToDiagnostic(w) {
+    const line = Math.max(0, (w.line ?? 1) - 1);
+    const col = Math.max(0, (w.col ?? 1) - 1);
+    const severity = LINT_SEVERITY_MAP[w.rule] ?? node_1.DiagnosticSeverity.Warning;
+    return {
+        severity,
+        range: {
+            start: { line, character: col },
+            end: { line, character: col + 80 },
+        },
+        message: w.message,
+        source: 'redscript-lint',
+        code: w.rule,
+    };
+}
 // ---------------------------------------------------------------------------
 // Decorator hover docs
 // ---------------------------------------------------------------------------
 const DECORATOR_DOCS = {
     tick: 'Runs every game tick.\n\n**Optional args:** `rate=N` (every N ticks, e.g. `@tick(rate=20)` = once per second)\n\nExample: `@tick fn every_tick() {}` or `@tick(rate=20) fn every_second() {}`',
     load: 'Runs once on `/reload`. Use for initialization.\n\nExample: `@load fn init() { scoreboard_create(...) }`',
+    watch: 'Runs when a scoreboard objective changes for a player.\n\n**Required arg:** objective name.\n\nExample: `@watch("rs.kills") fn on_kill_change() {}`',
     coroutine: 'Wraps a loop to spread execution across multiple ticks.\n\n**Required arg:** `batch=N` — iterations per tick.\n\nExample: `@coroutine(batch=10) fn scan_blocks() { for i in 0..1000 { ... } }`',
     schedule: 'Schedules the function to run after a delay.\n\n**Required arg:** `ticks=N`\n\nExample: `@schedule(ticks=100) fn delayed() {}`',
     on_trigger: 'Runs when a player executes `/trigger <name>`.\n\n**Required arg:** trigger objective name.\n\nExample: `@on_trigger("shop") fn open_shop() {}`',
@@ -265,10 +291,50 @@ function formatFnSignature(fn) {
     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. */
+/**
+ * Parse a raw triple-slash or block comment into structured sections.
+ * Supports @param name desc and @returns desc.
+ */
+function parseDocCommentText(raw) {
+    const result = { description: '', params: [], returns: null };
+    const descLines = [];
+    for (const line of raw.split('\n')) {
+        const paramMatch = line.match(/^@param\s+(\w+)\s+(.+)$/);
+        if (paramMatch) {
+            result.params.push({ name: paramMatch[1], doc: paramMatch[2].trim() });
+            continue;
+        }
+        const retMatch = line.match(/^@returns?\s+(.+)$/);
+        if (retMatch) {
+            result.returns = retMatch[1].trim();
+            continue;
+        }
+        // Skip @since / @example etc
+        if (/^@\w+/.test(line.trim()))
+            continue;
+        descLines.push(line);
+    }
+    result.description = descLines.join('\n').trim();
+    return result;
+}
+/**
+ * Format a ParsedDocComment into Markdown for LSP hover.
+ */
+function formatDocCommentMarkdown(doc) {
+    const parts = [];
+    if (doc.description)
+        parts.push(doc.description);
+    if (doc.params.length > 0) {
+        parts.push('\n**Parameters:**');
+        for (const p of doc.params) {
+            parts.push(`- \`${p.name}\` — ${p.doc}`);
+        }
+    }
+    if (doc.returns) {
+        parts.push(`\n**Returns:** ${doc.returns}`);
+    }
+    return parts.join('\n');
+}
 /**
  * Extract the leading doc comment (/** ... *\/) immediately before a function
  * declaration, returning it as plain text (tags stripped).
@@ -380,6 +446,7 @@ const TYPE_COMPLETIONS = [
 // VSCode will keep the completion open as user types more letters (filter by label).
 const DECORATOR_COMPLETIONS = [
     { label: '@tick', detail: 'Run every game tick (~20 Hz)', insertText: 'tick' },
+    { label: '@watch', detail: 'Run when a scoreboard objective changes', insertText: 'watch' },
     { label: '@load', detail: 'Run on /reload (initialization)', insertText: 'load' },
     { label: '@on_trigger', detail: 'Run when a player uses /trigger', insertText: 'on_trigger' },
     { label: '@schedule', detail: 'Schedule function after N ticks', insertText: 'schedule' },
@@ -449,6 +516,18 @@ function validateAndPublish(doc) {
     const source = doc.getText();
     const parsed = parseDocument(doc.uri, source);
     const diagnostics = parsed.errors.map(toDiagnostic);
+    // Also run lint rules and push them as lower-severity diagnostics
+    try {
+        const filePath = (() => { try {
+            return (0, url_1.fileURLToPath)(doc.uri);
+        }
+        catch {
+            return doc.uri;
+        } })();
+        const lintWarnings = (0, lint_1.lintString)(source, filePath);
+        diagnostics.push(...lintWarnings.map(lintWarningToDiagnostic));
+    }
+    catch { /* lint is best-effort; don't block diagnostics */ }
     connection.sendDiagnostics({ uri: doc.uri, diagnostics });
 }
 documents.onDidOpen(e => validateAndPublish(e.document));
@@ -551,9 +630,17 @@ connection.onHover((params) => {
     const fn = findFunction(program, word);
     if (fn) {
         const sig = formatFnSignature(fn);
+        const rawDoc = extractDocComment(source, fn);
+        let docSection = '';
+        if (rawDoc) {
+            const parsed = parseDocCommentText(rawDoc);
+            const md = formatDocCommentMarkdown(parsed);
+            if (md)
+                docSection = `\n\n${md}`;
+        }
         const content = {
             kind: node_1.MarkupKind.Markdown,
-            value: `\`\`\`redscript\n${sig}\n\`\`\``,
+            value: `\`\`\`redscript\n${sig}\n\`\`\`${docSection}`,
         };
         return { contents: content };
     }