redscript-mc 1.0.0 → 1.2.0

package/dist/__tests__/parser.test.js

@@ -23,6 +23,7 @@ describe('Parser', () => {
             const program = parse('');
             expect(program.namespace).toBe('test');
             expect(program.declarations).toEqual([]);
+            expect(program.implBlocks).toEqual([]);
             expect(program.enums).toEqual([]);
             expect(program.consts).toEqual([]);
         });
@@ -90,6 +91,12 @@ describe('Parser', () => {
                 { name: 'on_death' },
             ]);
         });
+        it('parses @on event decorators', () => {
+            const program = parse('@on(PlayerDeath)\nfn handle_death(player: Player) {}');
+            expect(program.declarations[0].decorators).toEqual([
+                { name: 'on', args: { eventType: 'PlayerDeath' } },
+            ]);
+        });
     });
     describe('types', () => {
         it('parses primitive types', () => {
@@ -134,6 +141,50 @@ describe('Parser', () => {
                 },
             ]);
         });
+        it('parses impl blocks', () => {
+            const program = parse(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int): Timer {
+    return { duration: duration };
+  }
+
+  fn start(self) {}
+}
+`);
+            expect(program.implBlocks).toHaveLength(1);
+            expect(program.implBlocks[0].typeName).toBe('Timer');
+            expect(program.implBlocks[0].methods.map(method => method.name)).toEqual(['new', 'start']);
+            expect(program.implBlocks[0].methods[1].params[0]).toEqual({
+                name: 'self',
+                type: { kind: 'struct', name: 'Timer' },
+                default: undefined,
+            });
+        });
+        it('parses impl blocks with static and instance methods', () => {
+            const program = parse(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn new(x: int, y: int) -> Point {
+    return { x: x, y: y };
+  }
+
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+`);
+            expect(program.implBlocks).toHaveLength(1);
+            expect(program.implBlocks[0].typeName).toBe('Point');
+            expect(program.implBlocks[0].methods[0].params.map(param => param.name)).toEqual(['x', 'y']);
+            expect(program.implBlocks[0].methods[1].params[0]).toEqual({
+                name: 'self',
+                type: { kind: 'struct', name: 'Point' },
+                default: undefined,
+            });
+        });
     });
     describe('statements', () => {
         it('parses let statement', () => {
@@ -173,6 +224,26 @@ describe('Parser', () => {
             expect(stmt.kind).toBe('if');
             expect(stmt.else_).toHaveLength(1);
         });
+        it('parses entity is-checks in if conditions', () => {
+            const stmt = parseStmt('if (e is Player) { kill(@s); }');
+            expect(stmt.kind).toBe('if');
+            expect(stmt.cond).toEqual({
+                kind: 'is_check',
+                expr: { kind: 'ident', name: 'e' },
+                entityType: 'Player',
+            });
+        });
+        it('parses entity is-checks inside foreach bodies', () => {
+            const stmt = parseStmt('foreach (e in @e) { if (e is Zombie) { kill(e); } }');
+            expect(stmt.kind).toBe('foreach');
+            const innerIf = stmt.body[0];
+            expect(innerIf.kind).toBe('if');
+            expect(innerIf.cond).toEqual({
+                kind: 'is_check',
+                expr: { kind: 'ident', name: 'e' },
+                entityType: 'Zombie',
+            });
+        });
         it('parses while statement', () => {
             const stmt = parseStmt('while (i > 0) { i = i - 1; }');
             expect(stmt.kind).toBe('while');
@@ -429,6 +500,15 @@ describe('Parser', () => {
                 });
             });
         });
+        it('parses static method calls', () => {
+            const expr = parseExpr('Timer::new(100)');
+            expect(expr).toEqual({
+                kind: 'static_call',
+                type: 'Timer',
+                method: 'new',
+                args: [{ kind: 'int_lit', value: 100 }],
+            });
+        });
         describe('binary operators', () => {
             it('parses arithmetic', () => {
                 const expr = parseExpr('1 + 2');

package/dist/__tests__/runtime.test.js

@@ -58,7 +58,7 @@ function loadExample(name) {
 }
 describe('MCRuntime behavioral integration', () => {
     it('runs the counter example and increments the scoreboard across ticks', () => {
-        const runtime = loadCompiledProgram(loadExample('counter.rs'));
+        const runtime = loadCompiledProgram(loadExample('counter.mcrs'));
         runtime.load();
         runtime.ticks(5);
         expect(runtime.getScore('counter', 'ticks')).toBe(5);
@@ -81,7 +81,7 @@ fn compute() {
 `);
         runtime.load();
         runtime.execFunction('compute');
-        expect(runtime.getScore('math', 'result')).toBe(11);
+        expect(runtime.getScore('math', 'runtime.result')).toBe(11);
     });
     it('captures say, announce, actionbar, and title output in the chat log', () => {
         const runtime = loadCompiledProgram(`
@@ -146,8 +146,8 @@ fn arrays() {
 `);
         runtime.load();
         runtime.execFunction('arrays');
-        expect(runtime.getScore('arrays', 'len')).toBe(1);
-        expect(runtime.getScore('arrays', 'last')).toBe(9);
+        expect(runtime.getScore('arrays', 'runtime.len')).toBe(1);
+        expect(runtime.getScore('arrays', 'runtime.last')).toBe(9);
         expect(runtime.getStorage('rs:heap.arr')).toEqual([4]);
     });
     it('tracks world state, weather, and time from compiled world commands', () => {
@@ -182,7 +182,7 @@ fn pulse() {
 `);
         runtime.load();
         runtime.ticks(10);
-        expect(runtime.getScore('pulse', 'count')).toBe(2);
+        expect(runtime.getScore('pulse', 'runtime.count')).toBe(2);
     });
     it('executes only the matching match arm', () => {
         const runtime = loadCompiledProgram(`
@@ -229,7 +229,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'direct')).toBe(10);
+        expect(runtime.getScore('lambda', 'runtime.direct')).toBe(10);
     });
     it('executes lambdas passed as callback arguments', () => {
         const runtime = loadCompiledProgram(`
@@ -244,7 +244,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'callback')).toBe(15);
+        expect(runtime.getScore('lambda', 'runtime.callback')).toBe(15);
     });
     it('executes block-body lambdas', () => {
         const runtime = loadCompiledProgram(`
@@ -259,7 +259,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'block')).toBe(11);
+        expect(runtime.getScore('lambda', 'runtime.block')).toBe(11);
     });
     it('executes immediately-invoked expression-body lambdas', () => {
         const runtime = loadCompiledProgram(`
@@ -270,7 +270,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'iife')).toBe(10);
+        expect(runtime.getScore('lambda', 'runtime.iife')).toBe(10);
     });
 });
 //# sourceMappingURL=runtime.test.js.map

package/dist/__tests__/typechecker.test.js

@@ -193,6 +193,137 @@ fn test() {
 `);
             expect(errors).toHaveLength(0);
         });
+        it('type checks timer builtins with void callbacks and interval IDs', () => {
+            const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => {
+        say("later");
+    });
+    let intervalId: int = setInterval(20, () => {
+        say("tick");
+    });
+    clearInterval(intervalId);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects timer callbacks with the wrong return type', () => {
+            const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => 1);
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('Return type mismatch: expected void, got int');
+        });
+        it('allows impl instance methods with inferred self type', () => {
+            const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+
+fn test() {
+  let timer: Timer = { duration: 10 };
+  let value: int = timer.elapsed();
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('records then-branch entity narrowing for is-checks', () => {
+            const source = `
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(e);
+        }
+    }
+}
+`;
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const ast = new parser_1.Parser(tokens).parse('test');
+            const checker = new typechecker_1.TypeChecker(source);
+            checker.check(ast);
+            const foreachStmt = ast.declarations[0].body[0];
+            const ifStmt = foreachStmt.body[0];
+            expect(checker.getThenBranchNarrowing(ifStmt.cond)).toEqual({
+                name: 'e',
+                type: { kind: 'entity', entityType: 'Player' },
+                mutable: false,
+            });
+        });
+        it('allows static impl method calls', () => {
+            const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int) -> Timer {
+    return { duration: duration };
+  }
+}
+
+fn test() {
+  let timer: Timer = Timer::new(10);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects using is-checks on non-entity values', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {
+        say("nope");
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'is' checks require an entity expression, got int");
+        });
+        it('rejects calling instance impl methods as static methods', () => {
+            const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+
+fn test() {
+  let total: int = Point::distance();
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Method 'Point::distance' is an instance method");
+        });
+    });
+    describe('entity is-check narrowing', () => {
+        it('allows entity type checks on foreach bindings', () => {
+            const errors = typeCheck(`
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(@s);
+        }
+    }
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects is-checks on non-entity expressions', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {}
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'is' checks require an entity expression");
+        });
     });
     describe('return type checking', () => {
         it('allows matching return type', () => {
@@ -360,5 +491,32 @@ fn broken() -> int {
             expect(errors.length).toBeGreaterThanOrEqual(3);
         });
     });
+    describe('event handlers', () => {
+        it('accepts matching @on event signatures', () => {
+            const errors = typeCheck(`
+@on(PlayerDeath)
+fn handle_death(player: Player) {
+    tp(player, @p);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects unknown event types', () => {
+            const errors = typeCheck(`
+@on(NotARealEvent)
+fn handle(player: Player) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Unknown event type 'NotARealEvent'");
+        });
+        it('rejects mismatched event signatures', () => {
+            const errors = typeCheck(`
+@on(BlockBreak)
+fn handle_break(player: Player) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('must declare 2 parameter(s)');
+        });
+    });
 });
 //# sourceMappingURL=typechecker.test.js.map

package/dist/ast/types.d.ts

@@ -12,6 +12,7 @@ export interface Span {
     endCol?: number;
 }
 export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double';
+export type EntityTypeName = 'entity' | 'Player' | 'Mob' | 'HostileMob' | 'PassiveMob' | 'Zombie' | 'Skeleton' | 'Creeper' | 'Spider' | 'Enderman' | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager' | 'ArmorStand' | 'Item' | 'Arrow';
 export type TypeNode = {
     kind: 'named';
     name: PrimitiveType;
@@ -28,6 +29,11 @@ export type TypeNode = {
     kind: 'function_type';
     params: TypeNode[];
     return: TypeNode;
+} | {
+    kind: 'entity';
+    entityType: EntityTypeName;
+} | {
+    kind: 'selector';
 };
 export interface LambdaParam {
     name: string;
@@ -54,6 +60,11 @@ export interface SelectorFilter {
     sort?: 'nearest' | 'furthest' | 'random' | 'arbitrary';
     nbt?: string;
     gamemode?: string;
+    x?: RangeExpr;
+    y?: RangeExpr;
+    z?: RangeExpr;
+    x_rotation?: RangeExpr;
+    y_rotation?: RangeExpr;
 }
 export interface EntitySelector {
     kind: SelectorKind;
@@ -138,6 +149,11 @@ export type Expr = {
     left: Expr;
     right: Expr;
     span?: Span;
+} | {
+    kind: 'is_check';
+    expr: Expr;
+    entityType: EntityTypeName;
+    span?: Span;
 } | {
     kind: 'unary';
     op: '!' | '-';
@@ -213,10 +229,14 @@ export type ExecuteSubcommand = {
     selector: EntitySelector;
 } | {
     kind: 'if_entity';
-    selector: EntitySelector;
+    selector?: EntitySelector;
+    varName?: string;
+    filters?: SelectorFilter;
 } | {
     kind: 'unless_entity';
-    selector: EntitySelector;
+    selector?: EntitySelector;
+    varName?: string;
+    filters?: SelectorFilter;
 } | {
     kind: 'in';
     dimension: string;
@@ -302,9 +322,10 @@ export type Stmt = {
 };
 export type Block = Stmt[];
 export interface Decorator {
-    name: 'tick' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team';
+    name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team';
     args?: {
         rate?: number;
+        eventType?: string;
         trigger?: string;
         advancement?: string;
         item?: string;
@@ -333,6 +354,12 @@ export interface StructDecl {
     fields: StructField[];
     span?: Span;
 }
+export interface ImplBlock {
+    kind: 'impl_block';
+    typeName: string;
+    methods: FnDecl[];
+    span?: Span;
+}
 export interface EnumVariant {
     name: string;
     value?: number;
@@ -348,10 +375,20 @@ export interface ConstDecl {
     value: LiteralExpr;
     span?: Span;
 }
+export interface GlobalDecl {
+    kind: 'global';
+    name: string;
+    type: TypeNode;
+    init: Expr;
+    mutable: boolean;
+    span?: Span;
+}
 export interface Program {
     namespace: string;
+    globals: GlobalDecl[];
     declarations: FnDecl[];
     structs: StructDecl[];
+    implBlocks: ImplBlock[];
     enums: EnumDecl[];
     consts: ConstDecl[];
 }

package/dist/cli.js

@@ -60,13 +60,15 @@ Usage:
   redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
+  redscript fmt <file.mcrs> [file2.mcrs ...]
   redscript repl
   redscript version
 
 Commands:
   compile   Compile a RedScript file to a Minecraft datapack
-  watch     Watch a directory for .rs file changes, recompile, and hot reload
+  watch     Watch a directory for .mcrs file changes, recompile, and hot reload
   check     Check a RedScript file for errors without generating output
+  fmt       Auto-format RedScript source files
   repl      Start an interactive RedScript REPL
   version   Print the RedScript version
 
@@ -275,18 +277,18 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
         console.error(`Error: ${dir} is not a directory`);
         process.exit(1);
     }
-    console.log(`👁  Watching ${dir} for .rs file changes...`);
+    console.log(`👁  Watching ${dir} for .mcrs file changes...`);
     console.log(`   Output: ${output}`);
     if (hotReloadUrl)
         console.log(`   Hot reload: ${hotReloadUrl}`);
     console.log(`   Press Ctrl+C to stop\n`);
     // Debounce timer
     let debounceTimer = null;
-    // Compile all .rs files in directory
+    // Compile all .mcrs files in directory
     async function compileAll() {
         const files = findRsFiles(dir);
         if (files.length === 0) {
-            console.log(`⚠  No .rs files found in ${dir}`);
+            console.log(`⚠  No .mcrs files found in ${dir}`);
             return;
         }
         let hasErrors = false;
@@ -321,7 +323,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
             console.log('');
         }
     }
-    // Find all .rs files recursively
+    // Find all .mcrs files recursively
     function findRsFiles(directory) {
         const results = [];
         const entries = fs.readdirSync(directory, { withFileTypes: true });
@@ -330,7 +332,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
             if (entry.isDirectory()) {
                 results.push(...findRsFiles(fullPath));
             }
-            else if (entry.isFile() && entry.name.endsWith('.rs')) {
+            else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
                 results.push(fullPath);
             }
         }
@@ -340,7 +342,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
     void compileAll();
     // Watch for changes
     fs.watch(dir, { recursive: true }, (eventType, filename) => {
-        if (filename && filename.endsWith('.rs')) {
+        if (filename && filename.endsWith('.mcrs')) {
             // Debounce rapid changes
             if (debounceTimer) {
                 clearTimeout(debounceTimer);
@@ -391,6 +393,22 @@ async function main() {
             }
             checkCommand(parsed.file);
             break;
+        case 'fmt':
+        case 'format': {
+            const files = args.filter(a => a.endsWith('.mcrs'));
+            if (files.length === 0) {
+                console.error('Usage: redscript fmt <file.mcrs> [file2.mcrs ...]');
+                process.exit(1);
+            }
+            const { format } = require('./formatter');
+            for (const file of files) {
+                const content = fs.readFileSync(file, 'utf8');
+                const formatted = format(content);
+                fs.writeFileSync(file, formatted);
+                console.log(`Formatted: ${file}`);
+            }
+            break;
+        }
         case 'repl':
             await (0, repl_1.startRepl)(parsed.namespace ?? 'repl');
             break;

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

@@ -11,7 +11,7 @@
  * Variable mapping:
  *   scoreboard objective: "rs"
  *   fake player:          "$<varname>"
- *   temporaries:          "$t0", "$t1", ...
+ *   temporaries:          "$_0", "$_1", ...
  *   return value:         "$ret"
  *   parameters:           "$p0", "$p1", ...
  */

package/dist/codegen/mcfunction/index.js

@@ -12,7 +12,7 @@
  * Variable mapping:
  *   scoreboard objective: "rs"
  *   fake player:          "$<varname>"
- *   temporaries:          "$t0", "$t1", ...
+ *   temporaries:          "$_0", "$_1", ...
  *   return value:         "$ret"
  *   parameters:           "$p0", "$p1", ...
  */
@@ -21,6 +21,7 @@ exports.countMcfunctionCommands = countMcfunctionCommands;
 exports.generateDatapackWithStats = generateDatapackWithStats;
 exports.generateDatapack = generateDatapack;
 const commands_1 = require("../../optimizer/commands");
+const types_1 = require("../../events/types");
 // ---------------------------------------------------------------------------
 // Utilities
 // ---------------------------------------------------------------------------
@@ -238,6 +239,8 @@ function generateDatapackWithStats(module, options = {}) {
     // Collect all trigger handlers
     const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
     const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
+    const eventHandlers = module.functions.filter((fn) => !!fn.eventHandler && (0, types_1.isEventTypeName)(fn.eventHandler.eventType));
+    const eventTypes = new Set(eventHandlers.map(fn => fn.eventHandler.eventType));
     // Collect all tick functions
     const tickFunctionNames = [];
     for (const fn of module.functions) {
@@ -258,13 +261,28 @@ function generateDatapackWithStats(module, options = {}) {
         `scoreboard objectives add ${OBJ} dummy`,
     ];
     for (const g of module.globals) {
-        loadLines.push(`scoreboard players set ${varRef(g)} ${OBJ} 0`);
+        loadLines.push(`scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`);
     }
     // Add trigger objectives
     for (const triggerName of triggerNames) {
         loadLines.push(`scoreboard objectives add ${triggerName} trigger`);
         loadLines.push(`scoreboard players enable @a ${triggerName}`);
     }
+    for (const eventType of eventTypes) {
+        const detection = types_1.EVENT_TYPES[eventType].detection;
+        if (eventType === 'PlayerDeath') {
+            loadLines.push('scoreboard objectives add rs.deaths deathCount');
+        }
+        else if (eventType === 'EntityKill') {
+            loadLines.push('scoreboard objectives add rs.kills totalKillCount');
+        }
+        else if (eventType === 'ItemUse') {
+            loadLines.push('# ItemUse detection requires a project-specific objective/tag setup');
+        }
+        else if (detection === 'tag' || detection === 'advancement') {
+            loadLines.push(`# ${eventType} detection expects tag ${types_1.EVENT_TYPES[eventType].tag} to be set externally`);
+        }
+    }
     // Generate trigger dispatch functions
     for (const triggerName of triggerNames) {
         const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName);
@@ -310,6 +328,12 @@ function generateDatapackWithStats(module, options = {}) {
             files.push({ path: filePath, content: lines.join('\n') });
         }
     }
+    // Call @load functions from __load
+    for (const fn of module.functions) {
+        if (fn.isLoadInit) {
+            loadLines.push(`function ${ns}:${fn.name}`);
+        }
+    }
     // Write __load.mcfunction
     files.push({
         path: `data/${ns}/function/__load.mcfunction`,
@@ -333,8 +357,19 @@ function generateDatapackWithStats(module, options = {}) {
             tickLines.push(`execute as @a[scores={${triggerName}=1..}] run function ${ns}:__trigger_${triggerName}_dispatch`);
         }
     }
+    if (eventHandlers.length > 0) {
+        tickLines.push('# Event checks');
+        for (const eventType of eventTypes) {
+            const tag = types_1.EVENT_TYPES[eventType].tag;
+            const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType);
+            for (const handler of handlers) {
+                tickLines.push(`execute as @a[tag=${tag}] run function ${ns}:${handler.name}`);
+            }
+            tickLines.push(`tag @a[tag=${tag}] remove ${tag}`);
+        }
+    }
     // Only generate __tick if there's something to run
-    if (tickFunctionNames.length > 0 || triggerNames.size > 0) {
+    if (tickFunctionNames.length > 0 || triggerNames.size > 0 || eventHandlers.length > 0) {
         files.push({
             path: `data/${ns}/function/__tick.mcfunction`,
             content: tickLines.join('\n'),