redscript-mc 2.6.0 → 2.6.2

package/dist/src/__tests__/timer-debug.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lower_1 = require("../hir/lower");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+test('debug HIR for Timer::new', () => {
+    const source = `
+struct Timer {
+    _id: int,
+    _duration: int
+}
+impl Timer {
+    fn new(duration: int) -> Timer {
+        return { _id: 0, _duration: duration };
+    }
+    fn start(self) {}
+}
+fn init() {
+    let t: Timer = Timer::new(20);
+    t.start();
+}
+`;
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens, source).parse('test');
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    const initFn = hir.functions.find(f => f.name === 'init');
+    console.log('HIR init body:', JSON.stringify(initFn?.body, null, 2));
+});
+//# sourceMappingURL=timer-debug.test.js.map

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

@@ -132,9 +132,11 @@ fn test() {
             expect(errors[0].message).toContain('expected string, got format_string');
         });
         it('rejects unsupported f-string placeholder types', () => {
+            // entity type is not allowed in f-string
             const errors = typeCheck(`
 fn test() {
-    say(f"Flag: {true}");
+    let e: entity = @s
+    say(f"Flag: {e}");
 }
 `);
             expect(errors.length).toBeGreaterThan(0);
@@ -605,10 +607,10 @@ fn handle(player: Player) {}
         it('rejects mismatched event signatures', () => {
             const errors = typeCheck(`
 @on(BlockBreak)
-fn handle_break(player: Player) {}
+fn handle_break() {}
 `);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors[0].message).toContain('must declare 2 parameter(s)');
+            expect(errors[0].message).toContain('must declare 1 parameter(s)');
         });
     });
 });

package/dist/src/__tests__/var-allocator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/var-allocator.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const var_allocator_1 = require("../codegen/var-allocator");
+describe('VarAllocator', () => {
+    describe('mangle mode (default)', () => {
+        it('generates sequential names: a, b, ..., z, aa, ab', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const names = [];
+            for (let i = 0; i < 28; i++) {
+                names.push(alloc.alloc(`var${i}`));
+            }
+            expect(names[0]).toBe('$a');
+            expect(names[1]).toBe('$b');
+            expect(names[25]).toBe('$z');
+            expect(names[26]).toBe('$aa');
+            expect(names[27]).toBe('$ab');
+        });
+        it('caches: same name returns same result', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const first = alloc.alloc('x');
+            const second = alloc.alloc('x');
+            expect(first).toBe(second);
+        });
+        it('constant() is content-addressed: same value returns same result', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const first = alloc.constant(42);
+            const second = alloc.constant(42);
+            expect(first).toBe(second);
+        });
+        it('different variables get different names', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const a = alloc.alloc('foo');
+            const b = alloc.alloc('bar');
+            expect(a).not.toBe(b);
+        });
+        it('alloc, constant, and internal share the same sequential pool', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const v = alloc.alloc('x'); // $a
+            const c = alloc.constant(1); // $b
+            const i = alloc.internal('ret'); // $c
+            expect(v).toBe('$a');
+            expect(c).toBe('$b');
+            expect(i).toBe('$c');
+        });
+        it('strips $ prefix from variable names', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const a = alloc.alloc('$foo');
+            const b = alloc.alloc('foo');
+            expect(a).toBe(b); // same underlying name
+        });
+    });
+    describe('no-mangle mode', () => {
+        it('uses $<name> for user vars', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.alloc('counter')).toBe('$counter');
+        });
+        it('uses $const_<value> for constants', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.constant(10)).toBe('$const_10');
+            expect(alloc.constant(-3)).toBe('$const_-3');
+        });
+        it('uses $<suffix> for internals', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.internal('ret')).toBe('$ret');
+            expect(alloc.internal('p0')).toBe('$p0');
+        });
+    });
+});
+//# sourceMappingURL=var-allocator.test.js.map

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

@@ -374,6 +374,20 @@ export type ExecuteSubcommand = {
     target: string;
     targetObj: string;
 };
+export type MatchPattern = {
+    kind: 'PatSome';
+    binding: string;
+} | {
+    kind: 'PatNone';
+} | {
+    kind: 'PatInt';
+    value: number;
+} | {
+    kind: 'PatWild';
+} | {
+    kind: 'PatExpr';
+    expr: Expr;
+};
 export type Stmt = {
     kind: 'let';
     name: string;
@@ -440,11 +454,17 @@ export type Stmt = {
     lenExpr: Expr;
     body: Block;
     span?: Span;
+} | {
+    kind: 'for_each';
+    binding: string;
+    array: Expr;
+    body: Block;
+    span?: Span;
 } | {
     kind: 'match';
     expr: Expr;
     arms: {
-        pattern: Expr | null;
+        pattern: MatchPattern;
         body: Block;
     }[];
     span?: Span;

package/dist/src/codegen/cmdblock/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Command Block Target
+ *
+ * Generates a JSON structure representing command blocks that can be
+ * placed in Minecraft to run the compiled datapack.
+ */
+export interface CommandBlock {
+    type: 'repeat' | 'impulse' | 'chain';
+    command: string;
+    pos: [number, number, number];
+    auto?: boolean;
+    conditional?: boolean;
+}
+export interface CommandBlockStructure {
+    format: 'redscript-cmdblock-v1';
+    namespace: string;
+    blocks: CommandBlock[];
+}
+/**
+ * Generate a command block structure JSON for a given namespace.
+ *
+ * Creates:
+ * - 1 × Repeat block: function <namespace>:__tick
+ * - 1 × Impulse block (auto): function <namespace>:__load
+ */
+export declare function generateCommandBlocks(namespace: string, hasTick: boolean, hasLoad: boolean): CommandBlockStructure;

package/dist/src/codegen/cmdblock/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Command Block Target
+ *
+ * Generates a JSON structure representing command blocks that can be
+ * placed in Minecraft to run the compiled datapack.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommandBlocks = generateCommandBlocks;
+/**
+ * Generate a command block structure JSON for a given namespace.
+ *
+ * Creates:
+ * - 1 × Repeat block: function <namespace>:__tick
+ * - 1 × Impulse block (auto): function <namespace>:__load
+ */
+function generateCommandBlocks(namespace, hasTick, hasLoad) {
+    const blocks = [];
+    let x = 0;
+    // Load block - impulse with auto (runs once when placed)
+    if (hasLoad) {
+        blocks.push({
+            type: 'impulse',
+            command: `function ${namespace}:__load`,
+            pos: [x, 0, 0],
+            auto: true,
+        });
+        x++;
+    }
+    // Tick block - repeat (runs every tick)
+    if (hasTick) {
+        blocks.push({
+            type: 'repeat',
+            command: `function ${namespace}:__tick`,
+            pos: [x, 0, 0],
+        });
+        x++;
+    }
+    return {
+        format: 'redscript-cmdblock-v1',
+        namespace,
+        blocks,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/src/codegen/mcfunction/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Code generator: IR → mcfunction datapack
+ *
+ * Output structure:
+ *   <namespace>/
+ *     functions/
+ *       <fn_name>.mcfunction
+ *       <fn_name>/<block_label>.mcfunction   (for control-flow continuations)
+ *     load.mcfunction     (objective setup)
+ *
+ * Variable mapping:
+ *   scoreboard objective: "rs"
+ *   fake player:          "$<varname>"
+ *   temporaries:          "$_0", "$_1", ...
+ *   return value:         "$ret"
+ *   parameters:           "$p0", "$p1", ...
+ */
+import type { IRModule } from '../../ir/types';
+import { type OptimizationStats } from '../../optimizer/commands';
+export interface DatapackFile {
+    path: string;
+    content: string;
+}
+export interface DatapackGenerationResult {
+    files: DatapackFile[];
+    advancements: DatapackFile[];
+    stats: OptimizationStats;
+    sourceMap?: Record<string, string>;
+}
+export interface DatapackGenerationOptions {
+    optimizeCommands?: boolean;
+    mangle?: boolean;
+    /** Scoreboard objective used for all scoreboard variables.
+     *  Defaults to 'rs'. Override per-datapack to avoid collisions
+     *  when multiple RedScript datapacks are loaded simultaneously. */
+    scoreboardObjective?: string;
+}
+export declare function countMcfunctionCommands(files: DatapackFile[]): number;
+export declare function generateDatapackWithStats(module: IRModule, options?: DatapackGenerationOptions): DatapackGenerationResult;
+export declare function generateDatapack(module: IRModule): DatapackFile[];