redscript-mc 2.4.1 → 2.6.0

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

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Tests for stdlib/sort.mcrs — insertion sort and merge utilities.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SORT_STDLIB = path.join(__dirname, '../../stdlib/sort.mcrs');
+const sortSrc = fs.readFileSync(SORT_STDLIB, 'utf-8');
+function compileWith(extra) {
+    const result = (0, compile_1.compile)(sortSrc + '\n' + extra, { namespace: 'test' });
+    return result.files;
+}
+describe('stdlib/sort.mcrs', () => {
+    test('compiles without errors', () => {
+        expect(() => {
+            const result = (0, compile_1.compile)(sortSrc, { namespace: 'test' });
+            expect(result.files.length).toBeGreaterThan(0);
+        }).not.toThrow();
+    });
+    test('insertion_sort function is emitted', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; insertion_sort(arr, 3); }`);
+        expect(files.some(f => f.path.includes('insertion_sort'))).toBe(true);
+    });
+    test('insertion_sort_desc function is emitted', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [10, 30, 20]; insertion_sort_desc(arr, 3); }`);
+        expect(files.some(f => f.path.includes('insertion_sort_desc'))).toBe(true);
+    });
+    test('sort_merge function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int[] {
+        let a: int[] = [10, 30, 50]
+        let b: int[] = [20, 40, 60]
+        return sort_merge(a, 3, b, 3)
+      }
+    `);
+        expect(files.some(f => f.path.includes('sort_merge'))).toBe(true);
+    });
+    test('insertion_sort on single element compiles', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [42]; insertion_sort(arr, 1); }`);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('insertion_sort on two elements compiles', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [5, 3]; insertion_sort(arr, 2); }`);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('insertion_sort_desc on two elements compiles', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [3, 5]; insertion_sort_desc(arr, 2); }`);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('sort_merge with empty second array compiles', () => {
+        const files = compileWith(`
+      @keep fn t(): int[] {
+        let a: int[] = [1, 2, 3]
+        let b: int[] = []
+        return sort_merge(a, 3, b, 0)
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('sort_merge result array contains storage operations', () => {
+        const files = compileWith(`
+      @keep fn t(): int[] {
+        let a: int[] = [1, 3]
+        let b: int[] = [2, 4]
+        return sort_merge(a, 2, b, 2)
+      }
+    `);
+        const mergeFile = files.find(f => f.path.includes('sort_merge'));
+        if (mergeFile) {
+            expect(mergeFile.content.length).toBeGreaterThan(0);
+        }
+    });
+    test('insertion_sort emit contains index write operations', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; insertion_sort(arr, 3); }`);
+        const sortFile = files.find(f => f.path.includes('insertion_sort') && !f.path.includes('desc'));
+        if (sortFile) {
+            expect(sortFile.content.length).toBeGreaterThan(0);
+        }
+    });
+    test('insertion_sort after sort_merge compiles (chaining)', () => {
+        const files = compileWith(`
+      @keep fn t() {
+        let a: int[] = [30, 10]
+        let b: int[] = [25, 5]
+        insertion_sort(a, 2)
+        insertion_sort(b, 2)
+        let merged: int[] = sort_merge(a, 2, b, 2)
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=sort.test.js.map

package/dist/src/__tests__/typechecker-strict.test.js

@@ -91,21 +91,21 @@ fn test() {
             expect(result.warnings).toHaveLength(0);
         });
     });
-    describe('int/float implicit conversion checks', () => {
-        it('detects int assigned to float variable', () => {
-            // int literal assigned to float — different types
+    describe('int/fixed implicit conversion checks', () => {
+        it('detects int assigned to fixed variable', () => {
+            // int literal assigned to fixed — different types
             const errors = typeCheck(`
 fn test() {
-    let x: float = 5;
+    let x: fixed = 5;
 }
 `);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors[0].message).toContain('cannot implicitly convert int to float');
-            expect(errors[0].message).toContain('as float');
+            expect(errors[0].message).toContain('cannot implicitly convert int to fixed');
+            expect(errors[0].message).toContain('as fixed');
         });
-        it('detects float assigned to int variable', () => {
+        it('detects fixed assigned to int variable', () => {
             const errors = typeCheck(`
-fn get_f() -> float {
+fn get_f() -> fixed {
     return 3.14;
 }
 fn test() {
@@ -115,24 +115,24 @@ fn test() {
             expect(errors.length).toBeGreaterThan(0);
             expect(errors[0].message).toContain('cannot implicitly convert');
         });
-        it('detects int/float return type mismatch', () => {
+        it('detects int/fixed return type mismatch', () => {
             const errors = typeCheck(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors[0].message).toContain('cannot implicitly convert int to float');
-            expect(errors[0].message).toContain('as float');
+            expect(errors[0].message).toContain('cannot implicitly convert int to fixed');
+            expect(errors[0].message).toContain('as fixed');
         });
-        it('detects float/int return type mismatch', () => {
+        it('detects fixed/int return type mismatch', () => {
             const errors = typeCheck(`
 fn get_int() -> int {
     return 3.14;
 }
 `);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors[0].message).toContain('cannot implicitly convert float to int');
+            expect(errors[0].message).toContain('cannot implicitly convert fixed to int');
             expect(errors[0].message).toContain('as int');
         });
         it('allows int assigned to int variable', () => {
@@ -143,27 +143,27 @@ fn test() {
 `);
             expect(errors).toHaveLength(0);
         });
-        it('allows float assigned to float variable', () => {
+        it('allows fixed assigned to fixed variable', () => {
             const errors = typeCheck(`
-fn get_f() -> float {
+fn get_f() -> fixed {
     return 3.14;
 }
 fn test() {
-    let x: float = get_f();
+    let x: fixed = get_f();
 }
 `);
             expect(errors).toHaveLength(0);
         });
-        it('blocks compilation on int→float mismatch', () => {
+        it('blocks compilation on int→fixed mismatch', () => {
             expect(() => compileStrict(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `)).toThrow();
         });
-        it('int→float mismatch demoted to warning in lenient mode', () => {
+        it('int→fixed mismatch demoted to warning in lenient mode', () => {
             const result = compileLenient(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `);

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

@@ -12,7 +12,7 @@ export interface Span {
     endLine?: number;
     endCol?: number;
 }
-export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string';
+export type PrimitiveType = 'int' | 'bool' | 'float' | 'fixed' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string';
 export type EntityTypeName = 'entity' | 'Player' | 'Mob' | 'HostileMob' | 'PassiveMob' | 'Zombie' | 'Skeleton' | 'Creeper' | 'Spider' | 'Enderman' | 'Blaze' | 'Witch' | 'Slime' | 'ZombieVillager' | 'Husk' | 'Drowned' | 'Stray' | 'WitherSkeleton' | 'CaveSpider' | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager' | 'WanderingTrader' | 'ArmorStand' | 'Item' | 'Arrow';
 export type TypeNode = {
     kind: 'named';
@@ -263,6 +263,11 @@ export type Expr = {
 } | {
     kind: 'none_lit';
     span?: Span;
+} | {
+    kind: 'type_cast';
+    expr: Expr;
+    targetType: TypeNode;
+    span?: Span;
 };
 export type LiteralExpr = Extract<Expr, {
     kind: 'int_lit';
@@ -425,6 +430,14 @@ export type Stmt = {
     varName: string;
     start: Expr;
     end: Expr;
+    inclusive?: boolean;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'for_in_array';
+    binding: string;
+    arrayName: string;
+    lenExpr: Expr;
     body: Block;
     span?: Span;
 } | {

package/dist/src/emit/compile.js

@@ -32,11 +32,14 @@ function compile(source, options = {}) {
     const tokens = lexer.tokenize();
     const parser = new parser_1.Parser(tokens, processedSource, filePath);
     const ast = parser.parse(namespace);
+    warnings.push(...parser.warnings);
     // Merge library imports (files with `module library;`) into AST
     for (const li of preprocessed.libraryImports ?? []) {
         const libPreprocessed = (0, compile_1.preprocessSourceWithMetadata)(li.source, { filePath: li.filePath });
         const libTokens = new lexer_1.Lexer(libPreprocessed.source, li.filePath).tokenize();
-        const libAst = new parser_1.Parser(libTokens, libPreprocessed.source, li.filePath).parse(namespace);
+        const libParser = new parser_1.Parser(libTokens, libPreprocessed.source, li.filePath);
+        const libAst = libParser.parse(namespace);
+        warnings.push(...libParser.warnings);
         for (const fn of libAst.declarations)
             fn.isLibraryFn = true;
         ast.declarations.push(...libAst.declarations);
@@ -67,6 +70,8 @@ function compile(source, options = {}) {
     {
         const checker = new typechecker_1.TypeChecker(processedSource, filePath);
         const typeErrors = checker.check(ast);
+        // Collect lint warnings (non-blocking — always added regardless of error mode)
+        warnings.push(...checker.getWarnings());
         if (typeErrors.length > 0) {
             if (lenient) {
                 for (const e of typeErrors) {
@@ -130,6 +135,18 @@ function compile(source, options = {}) {
             }
             warnings.push(diag.message);
         }
+        // Stage 6.5: Validate LIR score_set values are in MC int32 range
+        const INT32_MAX = 2147483647;
+        const INT32_MIN = -2147483648;
+        for (const fn of lirOpt.functions) {
+            for (const instr of fn.instructions) {
+                if (instr.kind === 'score_set' && (instr.value > INT32_MAX || instr.value < INT32_MIN)) {
+                    warnings.push(`[ConstantOverflow] function '${fn.name}': ` +
+                        `scoreboard immediate ${instr.value} is outside MC int32 range [${INT32_MIN}, ${INT32_MAX}]. ` +
+                        `This indicates a constant-folding overflow bug — please report this.`);
+                }
+            }
+        }
         // Stage 7: LIR → .mcfunction
         const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion });
         return { files, warnings, success: true };

package/dist/src/emit/index.js

@@ -129,7 +129,7 @@ function emitInstr(instr, ns, obj, mcVersion) {
         case 'store_score_to_nbt':
             return `execute store result storage ${instr.ns} ${instr.path} ${instr.type} ${instr.scale} run scoreboard players get ${slot(instr.src)}`;
         case 'store_nbt_to_score':
-            return `execute store result score ${slot(instr.dst)} run data get storage ${instr.ns} ${instr.path} ${instr.scale}`;
+            return `execute store result score ${slot(instr.dst)} run data get storage ${instr.ns} ${instr.path} ${Number.isInteger(instr.scale) ? instr.scale.toFixed(1) : instr.scale}`;
         case 'nbt_set_literal':
             return `data modify storage ${instr.ns} ${instr.path} set value ${instr.value}`;
         case 'nbt_copy':

package/dist/src/events/types.js

@@ -51,7 +51,7 @@ function toTypeNode(typeName) {
     if (typeName === 'Player') {
         return { kind: 'entity', entityType: 'Player' };
     }
-    if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
+    if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'fixed' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
         return { kind: 'named', name: typeName };
     }
     return { kind: 'struct', name: typeName };

package/dist/src/hir/lower.js

@@ -164,7 +164,7 @@ function lowerStmt(stmt) {
                 kind: 'while',
                 cond: {
                     kind: 'binary',
-                    op: '<',
+                    op: stmt.inclusive ? '<=' : '<',
                     left: { kind: 'ident', name: varName },
                     right: lowerExpr(stmt.end),
                 },
@@ -174,6 +174,57 @@ function lowerStmt(stmt) {
             };
             return [initStmt, whileStmt];
         }
+        // --- Desugaring: for_in_array → let idx = 0; while(idx < len) { let v = arr[idx]; body; idx = idx + 1 } ---
+        case 'for_in_array': {
+            const idxName = `__forin_idx_${stmt.binding}`;
+            const initStmt = {
+                kind: 'let',
+                name: idxName,
+                type: { kind: 'named', name: 'int' },
+                init: { kind: 'int_lit', value: 0 },
+                span: stmt.span,
+            };
+            const bindingInit = {
+                kind: 'let',
+                name: stmt.binding,
+                type: undefined,
+                init: {
+                    kind: 'index',
+                    obj: { kind: 'ident', name: stmt.arrayName },
+                    index: { kind: 'ident', name: idxName },
+                },
+                span: stmt.span,
+            };
+            const stepStmt = {
+                kind: 'expr',
+                expr: {
+                    kind: 'assign',
+                    target: idxName,
+                    value: {
+                        kind: 'binary',
+                        op: '+',
+                        left: { kind: 'ident', name: idxName },
+                        right: { kind: 'int_lit', value: 1 },
+                    },
+                },
+                span: stmt.span,
+            };
+            const body = [bindingInit, ...lowerBlock(stmt.body)];
+            const step = [stepStmt];
+            const whileStmt = {
+                kind: 'while',
+                cond: {
+                    kind: 'binary',
+                    op: '<',
+                    left: { kind: 'ident', name: idxName },
+                    right: lowerExpr(stmt.lenExpr),
+                },
+                body,
+                step,
+                span: stmt.span,
+            };
+            return [initStmt, whileStmt];
+        }
         case 'foreach':
             return {
                 kind: 'foreach',
@@ -409,6 +460,8 @@ function lowerExpr(expr) {
             return { kind: 'some_lit', value: lowerExpr(expr.value), span: expr.span };
         case 'none_lit':
             return { kind: 'none_lit', span: expr.span };
+        case 'type_cast':
+            return { kind: 'type_cast', expr: lowerExpr(expr.expr), targetType: expr.targetType, span: expr.span };
         case 'lambda': {
             const body = Array.isArray(expr.body) ? lowerBlock(expr.body) : lowerExpr(expr.body);
             return {

package/dist/src/hir/monomorphize.js

@@ -356,7 +356,7 @@ class Monomorphizer {
     inferExprType(expr, ctx) {
         switch (expr.kind) {
             case 'int_lit': return { kind: 'named', name: 'int' };
-            case 'float_lit': return { kind: 'named', name: 'float' };
+            case 'float_lit': return { kind: 'named', name: 'fixed' };
             case 'bool_lit': return { kind: 'named', name: 'bool' };
             case 'str_lit': return { kind: 'named', name: 'string' };
             case 'byte_lit': return { kind: 'named', name: 'byte' };

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

@@ -180,6 +180,11 @@ export type HIRExpr = {
 } | {
     kind: 'none_lit';
     span?: Span;
+} | {
+    kind: 'type_cast';
+    expr: HIRExpr;
+    targetType: TypeNode;
+    span?: Span;
 };
 export type HIRExecuteSubcommand = {
     kind: 'as';

package/dist/src/lexer/index.d.ts

@@ -5,7 +5,7 @@
  * Handles special cases like entity selectors vs decorators,
  * range literals, and raw commands.
  */
-export type TokenKind = 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module' | 'execute' | 'run' | 'unless' | 'declare' | 'export' | 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'true' | 'false' | 'selector' | 'decorator' | 'int_lit' | 'float_lit' | 'byte_lit' | 'short_lit' | 'long_lit' | 'double_lit' | 'string_lit' | 'f_string' | 'range_lit' | 'rel_coord' | 'local_coord' | '+' | '-' | '*' | '/' | '%' | '~' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||' | '!' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '{' | '}' | '(' | ')' | '[' | ']' | ',' | ';' | ':' | '::' | '->' | '=>' | '.' | 'ident' | 'mc_name' | 'raw_cmd' | 'eof';
+export type TokenKind = 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module' | 'execute' | 'run' | 'unless' | 'declare' | 'export' | 'int' | 'bool' | 'float' | 'fixed' | 'string' | 'void' | 'BlockPos' | 'true' | 'false' | 'selector' | 'decorator' | 'int_lit' | 'float_lit' | 'byte_lit' | 'short_lit' | 'long_lit' | 'double_lit' | 'string_lit' | 'f_string' | 'range_lit' | 'rel_coord' | 'local_coord' | '+' | '-' | '*' | '/' | '%' | '~' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||' | '!' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '{' | '}' | '(' | ')' | '[' | ']' | ',' | ';' | ':' | '::' | '->' | '=>' | '.' | 'ident' | 'mc_name' | 'raw_cmd' | 'eof';
 export interface Token {
     kind: TokenKind;
     value: string;

package/dist/src/lexer/index.js

@@ -43,6 +43,7 @@ const KEYWORDS = {
     int: 'int',
     bool: 'bool',
     float: 'float',
+    fixed: 'fixed',
     string: 'string',
     void: 'void',
     BlockPos: 'BlockPos',
@@ -201,6 +202,10 @@ class Lexer {
         if (char === '.' && this.peek() === '.') {
             this.advance(); // consume second .
             let value = '..';
+            // Check for inclusive range operator ..=
+            if (this.peek() === '=') {
+                value += this.advance(); // consume =
+            }
             while (/[0-9]/.test(this.peek())) {
                 value += this.advance();
             }
@@ -456,10 +461,14 @@ class Lexer {
         while (/[0-9]/.test(this.peek())) {
             value += this.advance();
         }
-        // Check for range literal (e.g., 1.., 1..10)
+        // Check for range literal (e.g., 1.., 1..10, 1..=10)
         if (this.peek() === '.' && this.peek(1) === '.') {
             value += this.advance(); // first .
             value += this.advance(); // second .
+            // Check for inclusive range operator =
+            if (this.peek() === '=') {
+                value += this.advance(); // consume =
+            }
             // Optional max value
             while (/[0-9]/.test(this.peek())) {
                 value += this.advance();