redscript-mc 3.0.0 → 3.0.2

package/dist/src/__tests__/parser.test.js

@@ -424,21 +424,12 @@ impl Point {
                 const expr = parseExpr('"hello"');
                 expect(expr).toEqual({ kind: 'str_lit', value: 'hello' });
             });
-            it('parses interpolated string literal', () => {
+            it('parses dollar-brace as plain string literal (no interpolation)', () => {
+                // ${...} in plain strings is NOT interpolated — only f"..." strings support {expr}
                 const expr = parseExpr('"Hello ${name}, score is ${score + 1}"');
                 expect(expr).toEqual({
-                    kind: 'str_interp',
-                    parts: [
-                        'Hello ',
-                        { kind: 'ident', name: 'name' },
-                        ', score is ',
-                        {
-                            kind: 'binary',
-                            op: '+',
-                            left: { kind: 'ident', name: 'score' },
-                            right: { kind: 'int_lit', value: 1 },
-                        },
-                    ],
+                    kind: 'str_lit',
+                    value: 'Hello ${name}, score is ${score + 1}',
                 });
             });
             it('parses f-string literal', () => {

package/dist/src/__tests__/repl-server-extra.test.js

@@ -44,9 +44,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const http = __importStar(require("http"));
 const repl_server_1 = require("../repl-server");
-// Use a different port from repl-server.test.ts (3000) to avoid port conflicts
-const PORT = 3001;
+// Use port 0 so the OS assigns a free port — avoids port conflicts
 const server = http.createServer(repl_server_1.requestHandler);
+let PORT = 0;
 function rawRequest(method, urlPath, body, headers = {}) {
     return new Promise((resolve, reject) => {
         const options = {
@@ -89,12 +89,11 @@ function jsonRequest(method, urlPath, body) {
     });
 }
 beforeAll(done => {
-    if (server.listening) {
+    server.listen(0, () => {
+        const addr = server.address();
+        PORT = addr.port;
         done();
-    }
-    else {
-        server.listen(PORT, done);
-    }
+    });
 });
 afterAll(done => {
     server.close(done);

package/dist/src/__tests__/repl-server.test.js

@@ -40,7 +40,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const http = __importStar(require("http"));
 const repl_server_1 = require("../repl-server");
-const PORT = 3000;
+let PORT = 0;
 function request(method, path, body) {
     return new Promise((resolve, reject) => {
         const payload = body !== undefined ? JSON.stringify(body) : undefined;
@@ -74,13 +74,11 @@ function request(method, path, body) {
     });
 }
 beforeAll(done => {
-    // If the server is already listening (e.g. imported elsewhere), just proceed.
-    if (repl_server_1.server.listening) {
+    repl_server_1.server.listen(0, () => {
+        const addr = repl_server_1.server.address();
+        PORT = addr.port;
         done();
-    }
-    else {
-        repl_server_1.server.listen(PORT, done);
-    }
+    });
 });
 afterAll(done => {
     repl_server_1.server.close(done);

package/dist/src/__tests__/stdlib/queue.test.js

@@ -59,18 +59,18 @@ describe('stdlib/queue.mcrs', () => {
     test('queue_pop reads head index from rs.q_head scoreboard', () => {
         const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
         const all = r.files.map(f => f.content).join('\n');
-        expect(all).toContain('scoreboard players get rs.q_head __RS__');
+        expect(all).toContain('scoreboard players get rs.q_head rs');
     });
     test('queue_pop advances head pointer after reading', () => {
         const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
         const all = r.files.map(f => f.content).join('\n');
-        expect(all).toContain('scoreboard players add rs.q_head __RS__ 1');
+        expect(all).toContain('scoreboard players add rs.q_head rs 1');
     });
     test('queue_pop uses __queue_peek_apply macro to read element', () => {
         const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
         const all = r.files.map(f => f.content).join('\n');
         expect(all).toContain('function test:__queue_peek_apply with storage rs:macro_args');
-        expect(all).toContain('$execute store result score $ret __test run data get storage rs:arrays Queue[$(idx)]');
+        expect(all).toContain('$execute store result score rs.peek_tmp rs run data get storage rs:arrays Queue[$(idx)]');
     });
     test('queue_peek uses __queue_peek_apply macro', () => {
         const r = compileWith(`@keep fn t(): int { return queue_peek(); }`);
@@ -80,18 +80,18 @@ describe('stdlib/queue.mcrs', () => {
     test('queue_size subtracts head from raw list length', () => {
         const r = compileWith(`@keep fn t(): int { return queue_size(); }`);
         const all = r.files.map(f => f.content).join('\n');
-        expect(all).toContain('scoreboard players operation $ret __test -= rs.q_head __RS__');
+        expect(all).toContain('scoreboard players operation $ret __test -= rs.q_head rs');
     });
     test('queue_size uses __queue_size_raw_apply to read raw list length', () => {
         const r = compileWith(`@keep fn t(): int { return queue_size(); }`);
         const all = r.files.map(f => f.content).join('\n');
-        expect(all).toContain('function test:__queue_size_raw_apply with storage rs:macro_args');
+        expect(all).toContain('function test:__queue_size_raw_apply');
     });
     test('queue_clear resets Queue list and head pointer', () => {
         const r = compileWith(`@keep fn t() { queue_clear(); }`);
         const all = r.files.map(f => f.content).join('\n');
         expect(all).toContain('data modify storage rs:arrays Queue set value []');
-        expect(all).toContain('scoreboard players set rs.q_head __RS__ 0');
+        expect(all).toContain('scoreboard players set rs.q_head rs 0');
     });
 });
 //# sourceMappingURL=queue.test.js.map

package/dist/src/__tests__/tuple.test.js

@@ -117,10 +117,16 @@ describe('Tuple: E2E compilation', () => {
         const result = (0, compile_1.compile)(source, { namespace: 'test' });
         const fn = getFile(result.files, 'use_divmod.mcfunction');
         expect(fn).toBeDefined();
-        // Should call divmod and then read from $ret_ slots
-        expect(fn).toContain('divmod');
-        expect(fn).toContain('$ret_0');
-        expect(fn).toContain('$ret_1');
+        // After auto-inline, divmod(10,3) may be inlined and constant-folded:
+        //   q = 10/3 = 3, r = 10%3 = 1, q+r = 4
+        // Either the call to divmod still exists OR the folded result (4) does.
+        const allContent = result.files.map(f => f.content).join('\n');
+        expect((fn ?? '').includes('divmod') ||
+            allContent.includes('4') // constant-folded result of 3+1
+        ).toBe(true);
+        // The $ret_ slots should either be in the caller or in divmod.mcfunction
+        expect(allContent).toContain('$ret_0');
+        expect(allContent).toContain('$ret_1');
     });
     test('tuple literal assigned directly via destructuring', () => {
         const source = `

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

@@ -557,7 +557,7 @@ export type Stmt = {
 };
 export type Block = Stmt[];
 export interface Decorator {
-    name: 'tick' | 'load' | 'watch' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team' | 'keep' | 'require_on_load' | 'coroutine' | 'schedule' | 'deprecated' | 'inline' | 'no-inline' | 'config' | 'singleton' | 'profile' | 'throttle' | 'retry' | 'memoize' | 'test';
+    name: 'tick' | 'load' | 'watch' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team' | 'keep' | 'require_on_load' | 'coroutine' | 'schedule' | 'deprecated' | 'inline' | 'no-inline' | 'config' | 'singleton' | 'profile' | 'benchmark' | 'throttle' | 'retry' | 'memoize' | 'test';
     args?: {
         rate?: number;
         objective?: string;

package/dist/src/check-fix.d.ts

@@ -0,0 +1,9 @@
+export interface CheckFixSummary {
+    removedUnusedImports: number;
+    removedDeadBranches: number;
+    annotatedMagicNumbers: number;
+}
+export declare function applyCheckFixes(source: string, filePath: string, namespace?: string): {
+    source: string;
+    summary: CheckFixSummary;
+};

package/dist/src/check-fix.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCheckFixes = applyCheckFixes;
+const lexer_1 = require("./lexer");
+const index_1 = require("./lint/index");
+const parser_1 = require("./parser");
+const lower_1 = require("./hir/lower");
+function applyCheckFixes(source, filePath, namespace = 'redscript') {
+    const firstPass = parseSource(source, namespace, filePath);
+    const structuralEdits = [];
+    for (const warning of firstPass.warnings) {
+        if (warning.rule !== 'unused-import' || warning.line == null)
+            continue;
+        const lineRange = getFullLineRange(source, warning.line);
+        structuralEdits.push({ start: lineRange.start, end: lineRange.end, replacement: '' });
+    }
+    const branchEdits = collectDeadBranchEdits(source, firstPass.program, firstPass.tokens);
+    structuralEdits.push(...branchEdits);
+    const filteredEdits = filterOverlappingEdits(structuralEdits);
+    const structurallyFixed = applyEdits(source, filteredEdits);
+    const secondPass = parseSource(structurallyFixed, namespace, filePath);
+    const annotated = annotateMagicNumbers(structurallyFixed, secondPass.warnings);
+    return {
+        source: annotated.source,
+        summary: {
+            removedUnusedImports: firstPass.warnings.filter(w => w.rule === 'unused-import').length,
+            removedDeadBranches: branchEdits.length,
+            annotatedMagicNumbers: annotated.count,
+        },
+    };
+}
+function parseSource(source, namespace, filePath) {
+    const lexer = new lexer_1.Lexer(source, filePath);
+    const tokens = lexer.tokenize();
+    const parser = new parser_1.Parser(tokens, source, filePath);
+    const program = parser.parse(namespace);
+    const hir = (0, lower_1.lowerToHIR)(program);
+    const warnings = (0, index_1.lintSource)(source, program.imports, hir, { filePath });
+    return { program, tokens, warnings };
+}
+function collectDeadBranchEdits(source, program, tokens) {
+    const edits = [];
+    const pushFromBlock = (block) => {
+        for (const stmt of block) {
+            pushFromStmt(stmt);
+        }
+    };
+    const pushFromStmt = (stmt) => {
+        if (stmt.kind === 'if') {
+            const constResult = evaluateConstBool(stmt.cond);
+            if (constResult !== null && stmt.span) {
+                const range = findStatementRange(source, tokens, stmt.span.line, stmt.span.col);
+                const replacement = constResult
+                    ? extractBlockReplacement(source, tokens[range.thenBraceStart], tokens[range.thenBraceEnd], getLineIndent(source, stmt.span.line))
+                    : extractElseReplacement(source, tokens, range, getLineIndent(source, stmt.span.line));
+                edits.push({ start: range.start, end: range.end, replacement });
+            }
+            pushFromBlock(stmt.then);
+            if (stmt.else_)
+                pushFromBlock(stmt.else_);
+            return;
+        }
+        switch (stmt.kind) {
+            case 'while':
+            case 'do_while':
+            case 'repeat':
+            case 'foreach':
+            case 'for_range':
+            case 'for_in_array':
+            case 'for_each':
+            case 'as_block':
+            case 'at_block':
+            case 'execute':
+            case 'while_let_some':
+                pushFromBlock(stmt.body);
+                break;
+            case 'for':
+                pushFromBlock(stmt.body);
+                break;
+            case 'match':
+                for (const arm of stmt.arms)
+                    pushFromBlock(arm.body);
+                break;
+            case 'if_let_some':
+                pushFromBlock(stmt.then);
+                if (stmt.else_)
+                    pushFromBlock(stmt.else_);
+                break;
+            case 'labeled_loop':
+                pushFromStmt(stmt.body);
+                break;
+            default:
+                break;
+        }
+    };
+    for (const fn of program.declarations)
+        pushFromBlock(fn.body);
+    for (const impl of program.implBlocks) {
+        for (const method of impl.methods)
+            pushFromBlock(method.body);
+    }
+    return filterOverlappingEdits(edits);
+}
+function evaluateConstBool(expr) {
+    if (expr.kind === 'bool_lit')
+        return expr.value;
+    if (expr.kind === 'binary') {
+        const leftNum = evaluateConstNumber(expr.left);
+        const rightNum = evaluateConstNumber(expr.right);
+        if (leftNum !== null && rightNum !== null) {
+            switch (expr.op) {
+                case '==': return leftNum === rightNum;
+                case '!=': return leftNum !== rightNum;
+                case '<': return leftNum < rightNum;
+                case '<=': return leftNum <= rightNum;
+                case '>': return leftNum > rightNum;
+                case '>=': return leftNum >= rightNum;
+            }
+        }
+        const leftBool = evaluateConstBool(expr.left);
+        const rightBool = evaluateConstBool(expr.right);
+        if (leftBool !== null && rightBool !== null) {
+            if (expr.op === '==')
+                return leftBool === rightBool;
+            if (expr.op === '!=')
+                return leftBool !== rightBool;
+        }
+    }
+    return null;
+}
+function evaluateConstNumber(expr) {
+    switch (expr.kind) {
+        case 'int_lit':
+        case 'float_lit':
+        case 'byte_lit':
+        case 'short_lit':
+        case 'long_lit':
+        case 'double_lit':
+            return expr.value;
+        default:
+            return null;
+    }
+}
+function findStatementRange(source, tokens, line, col) {
+    const startTokenIndex = tokens.findIndex(token => token.line === line && token.col === col && token.kind === 'if');
+    if (startTokenIndex === -1) {
+        throw new Error(`Could not locate if statement at ${line}:${col}`);
+    }
+    const thenBraceStart = findThenBraceStart(tokens, startTokenIndex);
+    const thenBraceEnd = findMatchingBrace(tokens, thenBraceStart);
+    const afterThen = thenBraceEnd + 1;
+    const statementStart = getLineStartOffset(source, line);
+    if (tokens[afterThen]?.kind === 'else') {
+        if (tokens[afterThen + 1]?.kind === 'if') {
+            const nested = findStatementRange(source, tokens, tokens[afterThen + 1].line, tokens[afterThen + 1].col);
+            return {
+                start: statementStart,
+                end: getLineEndOffset(source, tokens[nested.endTokenIndex].line),
+                endTokenIndex: nested.endTokenIndex,
+                thenBraceStart,
+                thenBraceEnd,
+                elseToken: afterThen,
+                elseBranchStart: afterThen + 1,
+                elseBranchEnd: nested.endTokenIndex,
+                elseIsIf: true,
+            };
+        }
+        const elseBraceStart = afterThen + 1;
+        const elseBraceEnd = findMatchingBrace(tokens, elseBraceStart);
+        return {
+            start: statementStart,
+            end: getLineEndOffset(source, tokens[elseBraceEnd].line),
+            endTokenIndex: elseBraceEnd,
+            thenBraceStart,
+            thenBraceEnd,
+            elseToken: afterThen,
+            elseBranchStart: elseBraceStart,
+            elseBranchEnd: elseBraceEnd,
+            elseIsIf: false,
+        };
+    }
+    return {
+        start: statementStart,
+        end: getLineEndOffset(source, tokens[thenBraceEnd].line),
+        endTokenIndex: thenBraceEnd,
+        thenBraceStart,
+        thenBraceEnd,
+    };
+}
+function findThenBraceStart(tokens, startIndex) {
+    let parenDepth = 0;
+    for (let i = startIndex + 1; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.kind === '(') {
+            parenDepth++;
+        }
+        else if (token.kind === ')') {
+            parenDepth--;
+        }
+        else if (token.kind === '{' && parenDepth === 0) {
+            return i;
+        }
+    }
+    throw new Error(`Could not locate block for if statement at ${tokens[startIndex].line}:${tokens[startIndex].col}`);
+}
+function findMatchingBrace(tokens, openBraceIndex) {
+    let depth = 0;
+    for (let i = openBraceIndex; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.kind === '{')
+            depth++;
+        if (token.kind === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    throw new Error(`Unmatched '{' at ${tokens[openBraceIndex].line}:${tokens[openBraceIndex].col}`);
+}
+function extractElseReplacement(source, tokens, range, baseIndent) {
+    if (range.elseBranchStart == null || range.elseBranchEnd == null) {
+        return '';
+    }
+    if (range.elseIsIf && range.elseToken != null) {
+        const startToken = tokens[range.elseToken];
+        const endToken = tokens[range.elseBranchEnd];
+        const text = source.slice(offsetFromLineCol(source, startToken.line, startToken.col), getLineEndOffset(source, endToken.line));
+        return normalizeElseIfSnippet(text, baseIndent);
+    }
+    return extractBlockReplacement(source, tokens[range.elseBranchStart], tokens[range.elseBranchEnd], baseIndent);
+}
+function extractBlockReplacement(source, openBrace, closeBrace, baseIndent) {
+    const openOffset = offsetFromLineCol(source, openBrace.line, openBrace.col) + openBrace.value.length;
+    const closeOffset = offsetFromLineCol(source, closeBrace.line, closeBrace.col);
+    const blockBody = source.slice(openOffset, closeOffset);
+    const normalized = normalizeBlockBody(blockBody, baseIndent);
+    return normalized.length > 0 ? `${normalized}\n` : '';
+}
+function normalizeBlockBody(blockBody, baseIndent) {
+    const lines = blockBody.split('\n');
+    while (lines.length > 0 && lines[0].trim() === '')
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1].trim() === '')
+        lines.pop();
+    if (lines.length === 0)
+        return '';
+    const nonEmpty = lines.filter(line => line.trim().length > 0);
+    const commonIndent = nonEmpty.reduce((current, line) => {
+        const indent = line.match(/^\s*/)?.[0] ?? '';
+        if (current === null)
+            return indent;
+        return indent.length < current.length ? indent : current;
+    }, null) ?? '';
+    return lines
+        .map(line => {
+        if (line.trim().length === 0)
+            return '';
+        const stripped = commonIndent && line.startsWith(commonIndent) ? line.slice(commonIndent.length) : line.trimStart();
+        return `${baseIndent}${stripped}`;
+    })
+        .join('\n');
+}
+function reindentSnippet(text, baseIndent) {
+    const lines = text.split('\n');
+    while (lines.length > 0 && lines[0].trim() === '')
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1].trim() === '')
+        lines.pop();
+    if (lines.length === 0)
+        return '';
+    const nonEmpty = lines.filter(line => line.trim().length > 0);
+    const commonIndent = nonEmpty.reduce((current, line) => {
+        const indent = line.match(/^\s*/)?.[0] ?? '';
+        if (current === null)
+            return indent;
+        return indent.length < current.length ? indent : current;
+    }, null) ?? '';
+    return `${lines
+        .map(line => {
+        if (line.trim().length === 0)
+            return '';
+        const stripped = commonIndent && line.startsWith(commonIndent) ? line.slice(commonIndent.length) : line.trimStart();
+        return `${baseIndent}${stripped}`;
+    })
+        .join('\n')}\n`;
+}
+function normalizeElseIfSnippet(text, baseIndent) {
+    const lines = text.split('\n');
+    while (lines.length > 0 && lines[lines.length - 1].trim() === '')
+        lines.pop();
+    if (lines.length === 0)
+        return '';
+    const firstLine = `${baseIndent}${lines[0].replace(/^else\s+/, '')}`;
+    const rest = lines.slice(1);
+    const nonEmptyRest = rest.filter(line => line.trim().length > 0);
+    const commonIndent = nonEmptyRest.reduce((current, line) => {
+        const indent = line.match(/^\s*/)?.[0] ?? '';
+        if (current === null)
+            return indent;
+        return indent.length < current.length ? indent : current;
+    }, null) ?? '';
+    const normalizedRest = rest.map(line => {
+        if (line.trim().length === 0)
+            return '';
+        const stripped = commonIndent && line.startsWith(commonIndent) ? line.slice(commonIndent.length) : line.trimStart();
+        return `${baseIndent}${stripped}`;
+    });
+    return `${[firstLine, ...normalizedRest].join('\n')}\n`;
+}
+function annotateMagicNumbers(source, warnings) {
+    const lines = source.split('\n');
+    const targetLines = Array.from(new Set(warnings
+        .filter(w => w.rule === 'magic-number' && w.line != null)
+        .map(w => w.line))).sort((a, b) => a - b);
+    let count = 0;
+    for (const lineNumber of targetLines) {
+        const index = lineNumber - 1;
+        if (index < 0 || index >= lines.length)
+            continue;
+        if (lines[index].includes('FIXME: consider const'))
+            continue;
+        lines[index] = `${lines[index]} // FIXME: consider const`;
+        count++;
+    }
+    return { source: lines.join('\n'), count };
+}
+function filterOverlappingEdits(edits) {
+    const sorted = [...edits].sort((a, b) => a.start - b.start || b.end - a.end);
+    const filtered = [];
+    for (const edit of sorted) {
+        const last = filtered[filtered.length - 1];
+        if (last && edit.start < last.end)
+            continue;
+        filtered.push(edit);
+    }
+    return filtered;
+}
+function applyEdits(source, edits) {
+    return [...edits]
+        .sort((a, b) => b.start - a.start)
+        .reduce((current, edit) => current.slice(0, edit.start) + edit.replacement + current.slice(edit.end), source);
+}
+function getFullLineRange(source, line) {
+    return {
+        start: getLineStartOffset(source, line),
+        end: getLineEndOffset(source, line),
+    };
+}
+function getLineStartOffset(source, line) {
+    return offsetFromLineCol(source, line, 1);
+}
+function getLineEndOffset(source, line) {
+    const lines = source.split('\n');
+    let offset = 0;
+    for (let i = 0; i < line - 1 && i < lines.length; i++) {
+        offset += lines[i].length + 1;
+    }
+    if (line - 1 < lines.length) {
+        offset += lines[line - 1].length;
+        if (line < lines.length)
+            offset += 1;
+    }
+    return offset;
+}
+function offsetFromLineCol(source, line, col) {
+    const lines = source.split('\n');
+    let offset = 0;
+    for (let i = 0; i < line - 1 && i < lines.length; i++) {
+        offset += lines[i].length + 1;
+    }
+    return offset + col - 1;
+}
+function getLineIndent(source, line) {
+    const content = source.split('\n')[line - 1] ?? '';
+    return content.match(/^\s*/)?.[0] ?? '';
+}
+//# sourceMappingURL=check-fix.js.map