redscript-mc 1.2.12 → 1.2.14

package/dist/__tests__/macro.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for MC 1.20.2+ macro function support
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), RedScript should
+ * automatically compile it as a macro function using $-prefixed syntax.
+ */
+export {};

package/dist/__tests__/macro.test.js

@@ -0,0 +1,305 @@
+"use strict";
+/**
+ * Tests for MC 1.20.2+ macro function support
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), RedScript should
+ * automatically compile it as a macro function using $-prefixed syntax.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lowering_1 = require("../lowering");
+const mcfunction_1 = require("../codegen/mcfunction");
+function compile(source, namespace = 'test') {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse(namespace);
+    const lowering = new lowering_1.Lowering(namespace);
+    return lowering.lower(ast);
+}
+function getFunction(module, name) {
+    return module.functions.find(f => f.name === name);
+}
+function getRawCommands(fn) {
+    return fn.blocks
+        .flatMap(b => b.instrs)
+        .filter((i) => i.op === 'raw')
+        .map(i => i.cmd);
+}
+function getGeneratedContent(module, fnName) {
+    const files = (0, mcfunction_1.generateDatapack)(module);
+    const file = files.find(f => f.path.includes(`/${fnName}.mcfunction`));
+    return file?.content;
+}
+// ---------------------------------------------------------------------------
+// Macro function detection
+// ---------------------------------------------------------------------------
+describe('MC macro function detection', () => {
+    it('marks function as macro when int param used in summon coordinates', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+`);
+        const fn = getFunction(ir, 'spawn_zombie');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBe(true);
+        expect(fn.macroParamNames).toEqual(expect.arrayContaining(['x', 'y', 'z']));
+    });
+    it('does NOT mark function as macro when all summon args are constants', () => {
+        const ir = compile(`
+fn spawn_fixed() {
+    summon("minecraft:zombie", 100, 64, 200);
+}
+`);
+        const fn = getFunction(ir, 'spawn_fixed');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBeFalsy();
+    });
+    it('marks function as macro when int param used in particle coordinates', () => {
+        const ir = compile(`
+fn show_particle(x: int, y: int, z: int) {
+    particle("minecraft:flame", x, y, z);
+}
+`);
+        const fn = getFunction(ir, 'show_particle');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBe(true);
+    });
+    it('marks function as macro when int param used in setblock coordinates', () => {
+        const ir = compile(`
+fn place_block(x: int, y: int, z: int) {
+    setblock(x, y, z, "minecraft:stone");
+}
+`);
+        const fn = getFunction(ir, 'place_block');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBe(true);
+        expect(fn.macroParamNames).toEqual(expect.arrayContaining(['x', 'y', 'z']));
+    });
+    it('identifies only the params used in macro positions', () => {
+        const ir = compile(`
+fn do_stuff(count: int, x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+    // count is not used in a macro position
+}
+`);
+        const fn = getFunction(ir, 'do_stuff');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBe(true);
+        // x, y, z should be macro params; count should NOT be
+        expect(fn.macroParamNames).toEqual(expect.arrayContaining(['x', 'y', 'z']));
+        expect(fn.macroParamNames).not.toContain('count');
+    });
+});
+// ---------------------------------------------------------------------------
+// Macro command generation in function body
+// ---------------------------------------------------------------------------
+describe('MC macro command generation', () => {
+    it('generates $-prefixed summon command with $(param) for macro params', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+`);
+        const fn = getFunction(ir, 'spawn_zombie');
+        const cmds = getRawCommands(fn);
+        // Should have a macro command for summon
+        const macroCmd = cmds.find(c => c.startsWith('$summon'));
+        expect(macroCmd).toBeDefined();
+        expect(macroCmd).toContain('$(x)');
+        expect(macroCmd).toContain('$(y)');
+        expect(macroCmd).toContain('$(z)');
+        expect(macroCmd).toBe('$summon minecraft:zombie $(x) $(y) $(z)');
+    });
+    it('generates non-prefixed command when args are literals', () => {
+        const ir = compile(`
+fn spawn_fixed() {
+    summon("minecraft:zombie", 100, 64, 200);
+}
+`);
+        const fn = getFunction(ir, 'spawn_fixed');
+        const cmds = getRawCommands(fn);
+        const summonCmd = cmds.find(c => c.includes('summon'));
+        expect(summonCmd).toBeDefined();
+        expect(summonCmd.startsWith('$')).toBe(false);
+        expect(summonCmd).toContain('100');
+        expect(summonCmd).toContain('64');
+        expect(summonCmd).toContain('200');
+    });
+    it('generates $-prefixed particle command with $(param)', () => {
+        const ir = compile(`
+fn show_particle(x: int, y: int, z: int) {
+    particle("minecraft:flame", x, y, z);
+}
+`);
+        const fn = getFunction(ir, 'show_particle');
+        const cmds = getRawCommands(fn);
+        const macroCmd = cmds.find(c => c.startsWith('$particle'));
+        expect(macroCmd).toBeDefined();
+        expect(macroCmd).toContain('$(x)');
+    });
+    it('generates $-prefixed setblock command with $(param)', () => {
+        const ir = compile(`
+fn place_block(x: int, y: int, z: int) {
+    setblock(x, y, z, "minecraft:stone");
+}
+`);
+        const fn = getFunction(ir, 'place_block');
+        const cmds = getRawCommands(fn);
+        const macroCmd = cmds.find(c => c.startsWith('$setblock'));
+        expect(macroCmd).toBeDefined();
+        expect(macroCmd).toContain('$(x)');
+        expect(macroCmd).toContain('$(y)');
+        expect(macroCmd).toContain('$(z)');
+        expect(macroCmd).toContain('minecraft:stone');
+    });
+});
+// ---------------------------------------------------------------------------
+// Call site code generation
+// ---------------------------------------------------------------------------
+describe('MC macro call site generation', () => {
+    it('emits NBT setup + with-storage call for variable args', () => {
+        const ir = compile(`
+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 callerFn = getFunction(ir, 'caller');
+        const cmds = getRawCommands(callerFn);
+        // Should have NBT setup for variable params (px → x, pz → z)
+        const xSetup = cmds.find(c => c.includes('macro_args') && c.includes(' x '));
+        const zSetup = cmds.find(c => c.includes('macro_args') && c.includes(' z '));
+        expect(xSetup).toBeDefined();
+        expect(zSetup).toBeDefined();
+        // Should have 'function test:spawn_zombie with storage rs:macro_args'
+        const callCmd = cmds.find(c => c.includes('spawn_zombie') && c.includes('with storage'));
+        expect(callCmd).toBeDefined();
+        expect(callCmd).toContain('rs:macro_args');
+    });
+    it('emits NBT setup for constant args too', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+
+fn caller_const() {
+    spawn_zombie(100, 64, 200);
+}
+`);
+        const callerFn = getFunction(ir, 'caller_const');
+        const cmds = getRawCommands(callerFn);
+        // Should have NBT setup for all macro params
+        const nbtCmds = cmds.filter(c => c.includes('macro_args'));
+        expect(nbtCmds.length).toBeGreaterThan(0);
+        // Should call with storage
+        const callCmd = cmds.find(c => c.includes('spawn_zombie') && c.includes('with storage'));
+        expect(callCmd).toBeDefined();
+    });
+    it('correctly sets up int variable args into NBT storage', () => {
+        const ir = compile(`
+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 callerFn = getFunction(ir, 'caller');
+        const cmds = getRawCommands(callerFn);
+        // For variable arg my_x → x: should use execute store result
+        const varSetup = cmds.find(c => c.includes('execute store result storage rs:macro_args x') &&
+            c.includes('scoreboard players get'));
+        expect(varSetup).toBeDefined();
+        // For constant 64 → y: should use data modify ... set value
+        const constSetup = cmds.find(c => c.includes('data modify storage rs:macro_args y set value 64'));
+        expect(constSetup).toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// Codegen output (mcfunction file content)
+// ---------------------------------------------------------------------------
+describe('MC macro function codegen output', () => {
+    it('generates $-prefixed lines in the macro function mcfunction file', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+`);
+        const content = getGeneratedContent(ir, 'spawn_zombie');
+        expect(content).toBeDefined();
+        expect(content).toContain('$summon minecraft:zombie $(x) $(y) $(z)');
+    });
+    it('generates correct call site in caller mcfunction file', () => {
+        const ir = compile(`
+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 content = getGeneratedContent(ir, 'caller');
+        expect(content).toBeDefined();
+        expect(content).toContain('with storage rs:macro_args');
+        expect(content).toContain('spawn_zombie');
+    });
+});
+// ---------------------------------------------------------------------------
+// Edge cases
+// ---------------------------------------------------------------------------
+describe('MC macro edge cases', () => {
+    it('handles mixed literal and variable args correctly', () => {
+        const ir = compile(`
+fn teleport_y(y: int) {
+    summon("minecraft:zombie", 100, y, 200);
+}
+`);
+        const fn = getFunction(ir, 'teleport_y');
+        expect(fn.isMacroFunction).toBe(true);
+        expect(fn.macroParamNames).toContain('y');
+        expect(fn.macroParamNames).not.toContain('x');
+        const cmds = getRawCommands(fn);
+        const macroCmd = cmds.find(c => c.startsWith('$summon'));
+        expect(macroCmd).toBeDefined();
+        // x and z are literals, y is macro
+        expect(macroCmd).toContain('100');
+        expect(macroCmd).toContain('$(y)');
+        expect(macroCmd).toContain('200');
+    });
+    it('non-macro functions still work normally', () => {
+        const ir = compile(`
+fn greet() {
+    say("hello world");
+}
+`);
+        const fn = getFunction(ir, 'greet');
+        expect(fn.isMacroFunction).toBeFalsy();
+        const cmds = getRawCommands(fn);
+        const sayCmd = cmds.find(c => c.includes('say') || c.includes('tellraw'));
+        expect(sayCmd).toBeDefined();
+        expect(sayCmd.startsWith('$')).toBe(false);
+    });
+    it('macro function with params used in arithmetic still works', () => {
+        const ir = compile(`
+fn spawn_offset(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+    // params are also used in the macro commands
+}
+`);
+        const fn = getFunction(ir, 'spawn_offset');
+        expect(fn.isMacroFunction).toBe(true);
+        // The macro commands should use $(param) syntax
+        const cmds = getRawCommands(fn);
+        const macroCmd = cmds.find(c => c.startsWith('$summon'));
+        expect(macroCmd).toBeDefined();
+        expect(macroCmd).toContain('$(x)');
+    });
+});
+//# sourceMappingURL=macro.test.js.map

package/dist/codegen/mcfunction/index.js

@@ -201,8 +201,16 @@ function applyFunctionOptimization(files) {
         commands: entry.commands,
     })));
     const commandMap = new Map(optimized.functions.map(fn => [fn.name, fn.commands]));
+    // Filter out files for functions that were removed (inlined trivial functions)
+    const optimizedNames = new Set(optimized.functions.map(fn => fn.name));
     return {
-        files: files.map(file => {
+        files: files
+            .filter(file => {
+            const functionName = toFunctionName(file);
+            // Keep non-function files and functions that weren't removed
+            return !functionName || optimizedNames.has(functionName);
+        })
+            .map(file => {
             const functionName = toFunctionName(file);
             if (!functionName)
                 return file;

package/dist/ir/types.d.ts

@@ -114,6 +114,8 @@ export interface IRFunction {
         eventType: string;
         tag: string;
     };
+    isMacroFunction?: boolean;
+    macroParamNames?: string[];
 }
 export interface GlobalVar {
     name: string;

package/dist/lowering/index.d.ts

@@ -47,7 +47,29 @@ export declare class Lowering {
     private floatVars;
     private worldObjCounter;
     private loopStack;
+    private currentFnParamNames;
+    private currentFnMacroParams;
+    private macroFunctionInfo;
     constructor(namespace: string, sourceRanges?: SourceRange[]);
+    private preScanMacroFunctions;
+    private preScanStmts;
+    private preScanStmt;
+    private preScanExpr;
+    /**
+     * If `expr` is a function parameter that needs macro treatment (runtime value
+     * used in a literal position), returns the param name; otherwise null.
+     */
+    private tryGetMacroParam;
+    /**
+     * Converts an expression to a string for use as a builtin arg.
+     * If the expression is a macro param, returns `$(name)` and sets macroParam.
+     */
+    private exprToBuiltinArg;
+    /**
+     * Emits a call to a macro function, setting up both scoreboard params
+     * (for arithmetic use) and NBT macro args (for coordinate/literal use).
+     */
+    private emitMacroFunctionCall;
     lower(program: Program): IRModule;
     private lowerFn;
     private getTickRate;
@@ -124,6 +146,7 @@ export declare class Lowering {
     private filePathForSpan;
     private lowerCoordinateBuiltin;
     private lowerTpCommand;
+    private lowerTpCommandMacroAware;
     private resolveBlockPosExpr;
     private getArrayStorageName;
     private inferLambdaReturnType;