redscript-mc 1.2.29 → 2.0.0

package/dist/src/types/entity-hierarchy.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Entity Type Hierarchy
+ *
+ * Closed inheritance tree mapping to Minecraft's entity registry.
+ * Used for type narrowing (is checks), selector<T> annotations,
+ * and W_IMPOSSIBLE_AS warnings.
+ */
+export interface EntityTypeNode {
+    name: string;
+    mcId: string | null;
+    abstract: boolean;
+    parent: string | null;
+}
+export declare const ENTITY_TYPES: EntityTypeNode[];
+/** Map from lowercase name → EntityTypeNode */
+export declare const ENTITY_TYPE_MAP: Map<string, EntityTypeNode>;
+/** Map from mcId (without namespace) → EntityTypeNode */
+export declare const ENTITY_TYPE_BY_MCID: Map<string, EntityTypeNode>;
+/** Check if typeA is a subtype of typeB (recursive ancestry) */
+export declare function isSubtype(typeA: string, typeB: string): boolean;
+/** True if one type is a subtype of the other (in either direction) */
+export declare function areCompatibleTypes(outerType: string, innerType: string): boolean;
+/** Get all non-abstract leaf types under a given node */
+export declare function getConcreteSubtypes(typeName: string): EntityTypeNode[];
+/** Parse "type=zombie" from a selector string, return the entity type name or null */
+export declare function getSelectorEntityType(selector: string): string | null;
+/** Determine the base entity type from a selector kind:
+ *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
+export declare function getBaseSelectorType(selector: string): string | null;

package/dist/src/types/entity-hierarchy.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Entity Type Hierarchy
+ *
+ * Closed inheritance tree mapping to Minecraft's entity registry.
+ * Used for type narrowing (is checks), selector<T> annotations,
+ * and W_IMPOSSIBLE_AS warnings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTITY_TYPE_BY_MCID = exports.ENTITY_TYPE_MAP = exports.ENTITY_TYPES = void 0;
+exports.isSubtype = isSubtype;
+exports.areCompatibleTypes = areCompatibleTypes;
+exports.getConcreteSubtypes = getConcreteSubtypes;
+exports.getSelectorEntityType = getSelectorEntityType;
+exports.getBaseSelectorType = getBaseSelectorType;
+exports.ENTITY_TYPES = [
+    // Root
+    { name: 'Entity', mcId: null, abstract: true, parent: null },
+    // Direct children of Entity
+    { name: 'Player', mcId: 'minecraft:player', abstract: false, parent: 'Entity' },
+    { name: 'ArmorStand', mcId: 'minecraft:armor_stand', abstract: false, parent: 'Entity' },
+    { name: 'Item', mcId: 'minecraft:item', abstract: false, parent: 'Entity' },
+    { name: 'Arrow', mcId: 'minecraft:arrow', abstract: false, parent: 'Entity' },
+    // Mob hierarchy
+    { name: 'Mob', mcId: null, abstract: true, parent: 'Entity' },
+    // Hostile mobs
+    { name: 'HostileMob', mcId: null, abstract: true, parent: 'Mob' },
+    { name: 'Zombie', mcId: 'minecraft:zombie', abstract: false, parent: 'HostileMob' },
+    { name: 'Skeleton', mcId: 'minecraft:skeleton', abstract: false, parent: 'HostileMob' },
+    { name: 'Creeper', mcId: 'minecraft:creeper', abstract: false, parent: 'HostileMob' },
+    { name: 'Spider', mcId: 'minecraft:spider', abstract: false, parent: 'HostileMob' },
+    { name: 'Enderman', mcId: 'minecraft:enderman', abstract: false, parent: 'HostileMob' },
+    { name: 'Blaze', mcId: 'minecraft:blaze', abstract: false, parent: 'HostileMob' },
+    { name: 'Witch', mcId: 'minecraft:witch', abstract: false, parent: 'HostileMob' },
+    { name: 'Slime', mcId: 'minecraft:slime', abstract: false, parent: 'HostileMob' },
+    { name: 'ZombieVillager', mcId: 'minecraft:zombie_villager', abstract: false, parent: 'HostileMob' },
+    { name: 'Husk', mcId: 'minecraft:husk', abstract: false, parent: 'HostileMob' },
+    { name: 'Drowned', mcId: 'minecraft:drowned', abstract: false, parent: 'HostileMob' },
+    { name: 'Stray', mcId: 'minecraft:stray', abstract: false, parent: 'HostileMob' },
+    { name: 'WitherSkeleton', mcId: 'minecraft:wither_skeleton', abstract: false, parent: 'HostileMob' },
+    { name: 'CaveSpider', mcId: 'minecraft:cave_spider', abstract: false, parent: 'HostileMob' },
+    // Passive mobs
+    { name: 'PassiveMob', mcId: null, abstract: true, parent: 'Mob' },
+    { name: 'Pig', mcId: 'minecraft:pig', abstract: false, parent: 'PassiveMob' },
+    { name: 'Cow', mcId: 'minecraft:cow', abstract: false, parent: 'PassiveMob' },
+    { name: 'Sheep', mcId: 'minecraft:sheep', abstract: false, parent: 'PassiveMob' },
+    { name: 'Chicken', mcId: 'minecraft:chicken', abstract: false, parent: 'PassiveMob' },
+    { name: 'Villager', mcId: 'minecraft:villager', abstract: false, parent: 'PassiveMob' },
+    { name: 'WanderingTrader', mcId: 'minecraft:wandering_trader', abstract: false, parent: 'PassiveMob' },
+];
+/** Map from lowercase name → EntityTypeNode */
+exports.ENTITY_TYPE_MAP = new Map(exports.ENTITY_TYPES.map(t => [t.name.toLowerCase(), t]));
+/** Map from mcId (without namespace) → EntityTypeNode */
+exports.ENTITY_TYPE_BY_MCID = new Map(exports.ENTITY_TYPES
+    .filter(t => t.mcId !== null)
+    .map(t => [t.mcId.replace('minecraft:', ''), t]));
+/** Check if typeA is a subtype of typeB (recursive ancestry) */
+function isSubtype(typeA, typeB) {
+    if (typeA === typeB)
+        return true;
+    const node = exports.ENTITY_TYPE_MAP.get(typeA.toLowerCase());
+    if (!node || !node.parent)
+        return false;
+    return isSubtype(node.parent, typeB);
+}
+/** True if one type is a subtype of the other (in either direction) */
+function areCompatibleTypes(outerType, innerType) {
+    return isSubtype(outerType, innerType) || isSubtype(innerType, outerType);
+}
+/** Get all non-abstract leaf types under a given node */
+function getConcreteSubtypes(typeName) {
+    const results = [];
+    for (const node of exports.ENTITY_TYPES) {
+        if (!node.abstract && isSubtype(node.name, typeName)) {
+            results.push(node);
+        }
+    }
+    return results;
+}
+/** Parse "type=zombie" from a selector string, return the entity type name or null */
+function getSelectorEntityType(selector) {
+    const match = selector.match(/type=(?:minecraft:)?([a-z_]+)/);
+    if (!match)
+        return null;
+    const mcId = match[1];
+    const node = exports.ENTITY_TYPE_BY_MCID.get(mcId);
+    return node ? node.name : null;
+}
+/** Determine the base entity type from a selector kind:
+ *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
+function getBaseSelectorType(selector) {
+    const trimmed = selector.trim();
+    // Check for type filter first (works for any selector)
+    const typeFromFilter = getSelectorEntityType(trimmed);
+    if (trimmed.startsWith('@a') || trimmed.startsWith('@p') || trimmed.startsWith('@r')) {
+        return typeFromFilter ?? 'Player';
+    }
+    if (trimmed.startsWith('@e')) {
+        return typeFromFilter ?? 'Entity';
+    }
+    // @s — context-dependent, we don't know unless there's a type filter
+    if (trimmed.startsWith('@s')) {
+        return typeFromFilter ?? null;
+    }
+    return null;
+}
+//# sourceMappingURL=entity-hierarchy.js.map

package/dist/src2/__tests__/e2e/basic.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * End-to-end tests for the v2 compiler pipeline.
+ *
+ * These tests compile RedScript source through the full pipeline
+ * (Lexer → Parser → HIR → MIR → optimize → LIR → emit) and verify
+ * the generated .mcfunction output contains expected MC commands.
+ */
+export {};

package/dist/src2/__tests__/e2e/basic.test.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * End-to-end tests for the v2 compiler pipeline.
+ *
+ * These tests compile RedScript source through the full pipeline
+ * (Lexer → Parser → HIR → MIR → optimize → LIR → emit) and verify
+ * the generated .mcfunction output contains expected MC commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+describe('e2e: basic compilation', () => {
+    test('simple arithmetic function produces scoreboard commands', () => {
+        const source = `
+      fn add(a: int, b: int): int {
+        return a + b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+        const addFn = getFile(result.files, 'add.mcfunction');
+        expect(addFn).toBeDefined();
+        expect(addFn).toContain('scoreboard players operation');
+        expect(addFn).toContain('__test');
+    });
+    test('pack.mcmeta is generated with pack_format 26', () => {
+        const source = `fn noop(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'demo' });
+        const meta = getFile(result.files, 'pack.mcmeta');
+        expect(meta).toBeDefined();
+        const parsed = JSON.parse(meta);
+        expect(parsed.pack.pack_format).toBe(26);
+    });
+    test('load.mcfunction creates scoreboard objective', () => {
+        const source = `fn noop(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'mypack' });
+        const load = getFile(result.files, 'load.mcfunction');
+        expect(load).toBeDefined();
+        expect(load).toContain('scoreboard objectives add __mypack dummy');
+    });
+    test('@tick function appears in tick.json', () => {
+        const source = `
+      @tick fn game_tick(): void {
+        let x: int = 1;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ticktest' });
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeDefined();
+        const parsed = JSON.parse(tickJson);
+        expect(parsed.values).toContain('ticktest:game_tick');
+    });
+    test('@load function appears in load.json', () => {
+        const source = `
+      @load fn setup(): void {
+        let x: int = 42;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'loadtest' });
+        const loadJson = getFile(result.files, 'load.json');
+        expect(loadJson).toBeDefined();
+        const parsed = JSON.parse(loadJson);
+        expect(parsed.values).toContain('loadtest:setup');
+        // load.json should also reference the objective-init load function
+        expect(parsed.values).toContain('loadtest:load');
+    });
+    test('if/else produces conditional call pattern', () => {
+        const source = `
+      fn check(x: int): int {
+        if (x > 0) {
+          return 1;
+        } else {
+          return 0;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'cond' });
+        // The main function should contain call_if_matches / call_unless_matches
+        const checkFn = getFile(result.files, 'check.mcfunction');
+        expect(checkFn).toBeDefined();
+        expect(checkFn).toContain('execute if score');
+        expect(checkFn).toContain('matches');
+        expect(checkFn).toContain('run function');
+    });
+    test('while loop produces loop structure with recursive call', () => {
+        const source = `
+      fn count(): void {
+        let i: int = 0;
+        while (i < 10) {
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'loop' });
+        // There should be a loop body function that calls itself (or a header)
+        const fnFiles = result.files.filter(f => f.path.endsWith('.mcfunction'));
+        expect(fnFiles.length).toBeGreaterThan(1); // main + at least one extracted block
+        // At least one file should have a conditional call pattern for the loop
+        const allContent = fnFiles.map(f => f.content).join('\n');
+        expect(allContent).toContain('execute if score');
+        expect(allContent).toContain('run function');
+    });
+    test('function names are lowercased in output paths', () => {
+        const source = `fn MyFunc(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const fn = result.files.find(f => f.path.includes('myfunc.mcfunction'));
+        expect(fn).toBeDefined();
+    });
+    test('constant assignment produces score_set', () => {
+        const source = `
+      fn init(): int {
+        let x: int = 42;
+        return x;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'cst' });
+        const fn = getFile(result.files, 'init.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('scoreboard players set');
+        expect(fn).toContain('42');
+    });
+    test('load.json always includes namespace:load', () => {
+        const source = `fn noop(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'abc' });
+        const loadJson = getFile(result.files, 'load.json');
+        expect(loadJson).toBeDefined();
+        const parsed = JSON.parse(loadJson);
+        expect(parsed.values).toContain('abc:load');
+    });
+    test('no tick.json when no @tick functions', () => {
+        const source = `fn noop(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'notick' });
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeUndefined();
+    });
+});
+//# sourceMappingURL=basic.test.js.map

package/dist/src2/__tests__/e2e/macros.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * End-to-end tests for MC 1.20.2+ macro function support in the v2 pipeline.
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), the compiler should
+ * automatically compile it as a macro function using $-prefixed syntax and
+ * call it via `function ns:fn with storage rs:macro_args`.
+ */
+export {};

package/dist/src2/__tests__/e2e/macros.test.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * End-to-end tests for MC 1.20.2+ macro function support in the v2 pipeline.
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), the compiler should
+ * automatically compile it as a macro function using $-prefixed syntax and
+ * call it via `function ns:fn with storage rs:macro_args`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+// ---------------------------------------------------------------------------
+// Macro function detection
+// ---------------------------------------------------------------------------
+describe('e2e: macro function detection', () => {
+    test('function with int params in summon coords emits $-prefixed command', () => {
+        const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'spawn_zombie.mcfunction');
+        expect(fn).toBeDefined();
+        // The function body should have a $summon macro line
+        expect(fn).toContain('$summon minecraft:zombie $(x) $(y) $(z)');
+    });
+    test('function with all constant args does NOT produce macro line', () => {
+        const source = `
+      fn spawn_fixed() {
+        summon("minecraft:zombie", 100, 64, 200);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'spawn_fixed.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('summon minecraft:zombie 100 64 200');
+        // No $ prefix
+        expect(fn).not.toMatch(/^\$summon/m);
+    });
+    test('function with int params in particle coords emits $-prefixed command', () => {
+        const source = `
+      fn show_particle(x: int, y: int, z: int) {
+        particle("minecraft:flame", x, y, z);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'show_particle.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$particle minecraft:flame $(x) $(y) $(z)');
+    });
+    test('function with int params in setblock coords emits $-prefixed command', () => {
+        const source = `
+      fn place_block(x: int, y: int, z: int) {
+        setblock(x, y, z, "minecraft:stone");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'place_block.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$setblock $(x) $(y) $(z) minecraft:stone');
+    });
+    test('mixed literal and variable args: only variable args get $()', () => {
+        const source = `
+      fn teleport_y(y: int) {
+        summon("minecraft:zombie", 100, y, 200);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'teleport_y.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$summon minecraft:zombie 100 $(y) 200');
+    });
+});
+// ---------------------------------------------------------------------------
+// Macro call site generation
+// ---------------------------------------------------------------------------
+describe('e2e: macro call site generation', () => {
+    test('call site emits store_score_to_nbt + function with storage', () => {
+        const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+
+      fn caller(px: int, pz: int) {
+        spawn_zombie(px, 64, pz);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const callerFn = getFile(result.files, 'caller.mcfunction');
+        expect(callerFn).toBeDefined();
+        // Should have 'function test:spawn_zombie with storage rs:macro_args'
+        expect(callerFn).toContain('with storage rs:macro_args');
+        expect(callerFn).toContain('spawn_zombie');
+    });
+    test('call site stores args to rs:macro_args NBT', () => {
+        const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+
+      fn caller(my_x: int) {
+        spawn_zombie(my_x, 64, 0);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const callerFn = getFile(result.files, 'caller.mcfunction');
+        expect(callerFn).toBeDefined();
+        // Should have NBT storage setup for macro args
+        expect(callerFn).toContain('rs:macro_args');
+        expect(callerFn).toContain('with storage');
+    });
+});
+// ---------------------------------------------------------------------------
+// Float macro params (local coords)
+// ---------------------------------------------------------------------------
+describe('e2e: float macro params with local coords', () => {
+    test('float params in ^coord positions produce macro function', () => {
+        const source = `
+      fn draw_pt(px: float, py: float) {
+        particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'draw_pt.mcfunction');
+        expect(fn).toBeDefined();
+        // Should have $particle with ^$(px) and ^$(py)
+        expect(fn).toContain('$particle minecraft:end_rod ^$(px) ^$(py) ^5');
+    });
+    test('float macro call site uses double 0.01 scale for NBT storage', () => {
+        const source = `
+      fn draw_pt(px: float, py: float) {
+        particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
+      }
+
+      fn caller() {
+        draw_pt(100, 200);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const callerFn = getFile(result.files, 'caller.mcfunction');
+        expect(callerFn).toBeDefined();
+        // Should store to NBT with double type and 0.01 scale
+        expect(callerFn).toContain('rs:macro_args');
+        expect(callerFn).toContain('double 0.01');
+        expect(callerFn).toContain('with storage rs:macro_args');
+    });
+});
+// ---------------------------------------------------------------------------
+// Non-macro functions still work
+// ---------------------------------------------------------------------------
+describe('e2e: non-macro functions', () => {
+    test('say builtin emits normal (non-macro) command', () => {
+        const source = `
+      fn greet() {
+        say("hello world");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'greet.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('say hello world');
+        // No $ prefix
+        expect(fn).not.toMatch(/^\$/m);
+    });
+    test('kill builtin emits normal command', () => {
+        const source = `
+      fn cleanup() {
+        kill(@e[tag=temp]);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'cleanup.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('kill @e[tag=temp]');
+    });
+});
+//# sourceMappingURL=macros.test.js.map

package/dist/src2/__tests__/e2e/migrate.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Migration tests — representative cases from the existing 920-test suite
+ * run through the NEW v2 compiler pipeline.
+ *
+ * Pattern:
+ *   1. Compile source with src2/emit/compile.ts
+ *   2. Load .mcfunction files into MCRuntime
+ *   3. Execute functions and assert scoreboard state
+ *
+ * NOTE: v2 uses objective `__<ns>` (not `rs`), load function is `ns:load`
+ * (not `ns:__load`), and return values go to `$ret` on the objective.
+ */
+export {};