redscript-mc 1.2.10 → 1.2.12

package/dist/parser/index.js

@@ -546,11 +546,11 @@ class Parser {
         this.expect('in');
         const iterable = this.parseExpr();
         this.expect(')');
-        // Parse optional execute context modifiers (at, positioned, rotated, facing, etc.)
+        // Parse optional execute context modifiers (as, at, positioned, rotated, facing, etc.)
         let executeContext;
-        // Check for 'at' keyword or identifiers like 'positioned', 'rotated', 'facing', 'anchored', 'align'
-        const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align'];
-        if (this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
+        // Check for execute subcommand keywords
+        const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align', 'on', 'summon'];
+        if (this.check('as') || this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
             // Collect everything until we hit '{'
             let context = '';
             while (!this.check('{') && !this.check('eof')) {
@@ -615,34 +615,175 @@ class Parser {
                 const selector = this.parseSelector();
                 subcommands.push({ kind: 'at', selector });
             }
-            else if (this.match('if')) {
-                // Expect 'entity' keyword (as ident) or just parse selector directly
-                if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
-                    this.advance(); // consume 'entity'
+            else if (this.checkIdent('positioned')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'positioned_as', selector });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'positioned', x, y, z });
                 }
-                const selectorOrVar = this.parseSelectorOrVarSelector();
-                subcommands.push({ kind: 'if_entity', ...selectorOrVar });
             }
-            else if (this.match('unless')) {
-                // Expect 'entity' keyword (as ident) or just parse selector directly  
-                if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
-                    this.advance(); // consume 'entity'
+            else if (this.checkIdent('rotated')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'rotated_as', selector });
+                }
+                else {
+                    const yaw = this.parseCoordToken();
+                    const pitch = this.parseCoordToken();
+                    subcommands.push({ kind: 'rotated', yaw, pitch });
+                }
+            }
+            else if (this.checkIdent('facing')) {
+                this.advance();
+                if (this.checkIdent('entity')) {
+                    this.advance();
+                    const selector = this.parseSelector();
+                    const anchor = this.checkIdent('eyes') || this.checkIdent('feet') ? this.advance().value : 'feet';
+                    subcommands.push({ kind: 'facing_entity', selector, anchor });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'facing', x, y, z });
+                }
+            }
+            else if (this.checkIdent('anchored')) {
+                this.advance();
+                const anchor = this.advance().value;
+                subcommands.push({ kind: 'anchored', anchor });
+            }
+            else if (this.checkIdent('align')) {
+                this.advance();
+                const axes = this.advance().value;
+                subcommands.push({ kind: 'align', axes });
+            }
+            else if (this.checkIdent('on')) {
+                this.advance();
+                const relation = this.advance().value;
+                subcommands.push({ kind: 'on', relation });
+            }
+            else if (this.checkIdent('summon')) {
+                this.advance();
+                const entity = this.advance().value;
+                subcommands.push({ kind: 'summon', entity });
+            }
+            else if (this.checkIdent('store')) {
+                this.advance();
+                const storeType = this.advance().value; // 'result' or 'success'
+                if (this.checkIdent('score')) {
+                    this.advance();
+                    const target = this.advance().value;
+                    const targetObj = this.advance().value;
+                    if (storeType === 'result') {
+                        subcommands.push({ kind: 'store_result', target, targetObj });
+                    }
+                    else {
+                        subcommands.push({ kind: 'store_success', target, targetObj });
+                    }
+                }
+                else {
+                    this.error('store currently only supports score target');
                 }
-                const selectorOrVar = this.parseSelectorOrVarSelector();
-                subcommands.push({ kind: 'unless_entity', ...selectorOrVar });
+            }
+            else if (this.match('if')) {
+                this.parseExecuteCondition(subcommands, 'if');
+            }
+            else if (this.match('unless')) {
+                this.parseExecuteCondition(subcommands, 'unless');
             }
             else if (this.match('in')) {
-                const dim = this.expect('ident').value;
+                // Dimension can be namespaced: minecraft:the_nether
+                let dim = this.advance().value;
+                if (this.match(':')) {
+                    dim += ':' + this.advance().value;
+                }
                 subcommands.push({ kind: 'in', dimension: dim });
             }
             else {
-                this.error(`Unexpected token in execute statement: ${this.peek().kind}`);
+                this.error(`Unexpected token in execute statement: ${this.peek().kind} (${this.peek().value})`);
             }
         }
         this.expect('run');
         const body = this.parseBlock();
         return this.withLoc({ kind: 'execute', subcommands, body }, executeToken);
     }
+    parseExecuteCondition(subcommands, type) {
+        if (this.checkIdent('entity') || this.check('selector')) {
+            if (this.checkIdent('entity'))
+                this.advance();
+            const selectorOrVar = this.parseSelectorOrVarSelector();
+            subcommands.push({ kind: type === 'if' ? 'if_entity' : 'unless_entity', ...selectorOrVar });
+        }
+        else if (this.checkIdent('block')) {
+            this.advance();
+            const x = this.parseCoordToken();
+            const y = this.parseCoordToken();
+            const z = this.parseCoordToken();
+            const block = this.parseBlockId();
+            subcommands.push({ kind: type === 'if' ? 'if_block' : 'unless_block', pos: [x, y, z], block });
+        }
+        else if (this.checkIdent('score')) {
+            this.advance();
+            const target = this.advance().value;
+            const targetObj = this.advance().value;
+            // Check for range or comparison
+            if (this.checkIdent('matches')) {
+                this.advance();
+                const range = this.advance().value;
+                subcommands.push({ kind: type === 'if' ? 'if_score_range' : 'unless_score_range', target, targetObj, range });
+            }
+            else {
+                const op = this.advance().value; // <, <=, =, >=, >
+                const source = this.advance().value;
+                const sourceObj = this.advance().value;
+                subcommands.push({
+                    kind: type === 'if' ? 'if_score' : 'unless_score',
+                    target, targetObj, op, source, sourceObj
+                });
+            }
+        }
+        else {
+            this.error(`Unknown condition type after ${type}`);
+        }
+    }
+    parseCoordToken() {
+        // Handle ~, ^, numbers, relative coords like ~5, ^-3
+        const token = this.peek();
+        if (token.kind === 'rel_coord' || token.kind === 'local_coord' ||
+            token.kind === 'int_lit' || token.kind === 'float_lit' ||
+            token.kind === '-' || token.kind === 'ident') {
+            return this.advance().value;
+        }
+        this.error(`Expected coordinate, got ${token.kind}`);
+        return '~';
+    }
+    parseBlockId() {
+        // Parse block ID like minecraft:stone or stone
+        let id = this.advance().value;
+        if (this.match(':')) {
+            id += ':' + this.advance().value;
+        }
+        // Handle block states [facing=north]
+        if (this.check('[')) {
+            id += this.advance().value; // [
+            while (!this.check(']') && !this.check('eof')) {
+                id += this.advance().value;
+            }
+            id += this.advance().value; // ]
+        }
+        return id;
+    }
+    checkIdent(value) {
+        return this.check('ident') && this.peek().value === value;
+    }
     parseExprStmt() {
         const expr = this.parseExpr();
         this.expect(';');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/dce.test.ts

@@ -14,17 +14,18 @@ function getFileContent(files: ReturnType<typeof compile>['files'], suffix: stri
 }
 
 describe('AST dead code elimination', () => {
-  it('removes unused functions reachable from entry points', () => {
+  it('removes private unused functions (prefixed with _)', () => {
     const source = `
-fn unused() { say("never called"); }
+fn _unused() { say("never called"); }
 fn used() { say("called"); }
 @tick fn main() { used(); }
 `
 
     const result = compile(source, { namespace: 'test' })
 
+    // _unused is removed because it starts with _ (private) and is not called
     expect(result.ast.declarations.map(fn => fn.name)).toEqual(['used', 'main'])
-    expect(result.ir.functions.some(fn => fn.name === 'unused')).toBe(false)
+    expect(result.ir.functions.some(fn => fn.name === '_unused')).toBe(false)
   })
 
   it('removes unused local variables from the AST body', () => {

package/src/__tests__/e2e.test.ts

@@ -196,8 +196,8 @@ fn main() {
       const thenFiles = files.filter(file => file.path.includes('/main/then_') && file.content.includes('kill @s'))
 
       expect(mainFn).toContain('execute as @e run function test:main/foreach_0')
-      expect(foreachFn).toContain('execute if entity @s[type=player] run function test:main/then_')
-      expect(foreachFn).toContain('execute if entity @s[type=zombie] run function test:main/then_')
+      expect(foreachFn).toContain('execute if entity @s[type=minecraft:player] run function test:main/then_')
+      expect(foreachFn).toContain('execute if entity @s[type=minecraft:zombie] run function test:main/then_')
       expect(thenFiles).toHaveLength(2)
     })
   })

package/src/__tests__/fixtures/array-test.mcrs

@@ -0,0 +1,30 @@
+// Array operations test
+
+@tick fn test_array() {
+    // Array initialization
+    let nums: int[] = [10, 20, 30, 40, 50];
+    
+    // Array access
+    scoreboard_set("#arr_0", #rs, nums[0]);
+    scoreboard_set("#arr_2", #rs, nums[2]);
+    scoreboard_set("#arr_4", #rs, nums[4]);
+    
+    // Array length via .len property
+    scoreboard_set("#arr_len", #rs, nums.len);
+    
+    // Sum via foreach
+    let sum: int = 0;
+    foreach (n in nums) {
+        sum = sum + n;
+    }
+    scoreboard_set("#arr_sum", #rs, sum);
+    
+    // Push operation
+    let arr2: int[] = [1, 2, 3];
+    arr2.push(4);
+    scoreboard_set("#arr_push", #rs, arr2.len);
+    
+    // Pop operation
+    let popped: int = arr2.pop();
+    scoreboard_set("#arr_pop", #rs, popped);
+}

package/src/__tests__/fixtures/break-continue-test.mcrs

@@ -0,0 +1,46 @@
+// Break and continue statements test
+
+fn test_break_continue() {
+    // Test break - should stop at i=5
+    let break_at: int = -1;
+    for (let i: int = 0; i < 10; i = i + 1) {
+        if (i == 5) {
+            break_at = i;
+            break;
+        }
+    }
+    scoreboard_set("#break_at", #rs, break_at);
+    
+    // Test continue - sum only even numbers
+    let sum_evens: int = 0;
+    for (let i: int = 0; i < 10; i = i + 1) {
+        if (i % 2 != 0) {
+            continue;
+        }
+        sum_evens = sum_evens + i;
+    }
+    // 0+2+4+6+8 = 20
+    scoreboard_set("#sum_evens", #rs, sum_evens);
+    
+    // While with break
+    let count: int = 0;
+    while (true) {
+        count = count + 1;
+        if (count >= 7) {
+            break;
+        }
+    }
+    scoreboard_set("#while_break", #rs, count);
+    
+    // Nested loop break (breaks inner only)
+    let outer_count: int = 0;
+    for (let a: int = 0; a < 3; a = a + 1) {
+        for (let b: int = 0; b < 10; b = b + 1) {
+            if (b == 2) {
+                break;
+            }
+        }
+        outer_count = outer_count + 1;
+    }
+    scoreboard_set("#nested_break", #rs, outer_count);
+}

package/src/__tests__/fixtures/enum-test.mcrs

@@ -0,0 +1,37 @@
+// Enum definition and matching test
+
+enum GamePhase {
+    Lobby,      // 0
+    Starting,   // 1
+    Playing,    // 2
+    Ended       // 3
+}
+
+enum Rank {
+    Bronze = 1,
+    Silver = 2,
+    Gold = 3,
+    Diamond = 10
+}
+
+fn test_enum() {
+    // Basic enum value (use . not ::)
+    let phase: int = GamePhase.Playing;
+    scoreboard_set("#enum_phase", #rs, phase);
+    
+    // Match on enum
+    match (phase) {
+        GamePhase.Lobby => { scoreboard_set("#enum_match", #rs, 0); }
+        GamePhase.Playing => { scoreboard_set("#enum_match", #rs, 2); }
+        _ => { scoreboard_set("#enum_match", #rs, -1); }
+    }
+    
+    // Custom values
+    let rank: int = Rank.Diamond;
+    scoreboard_set("#enum_rank", #rs, rank);
+    
+    // Comparison
+    if (rank > Rank.Gold) {
+        scoreboard_set("#enum_high", #rs, 1);
+    }
+}

package/src/__tests__/fixtures/foreach-at-test.mcrs

@@ -0,0 +1,33 @@
+// Foreach with execute context modifiers test
+
+@load fn setup() {
+    scoreboard_add("rs");
+    scoreboard_set("#foreach_count", #rs, 0);
+    scoreboard_set("#foreach_at_count", #rs, 0);
+}
+
+fn test_foreach_at() {
+    // Spawn test entities
+    raw("summon minecraft:armor_stand ~ ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    raw("summon minecraft:armor_stand ~2 ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    raw("summon minecraft:armor_stand ~4 ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    
+    // Basic foreach
+    let count: int = 0;
+    foreach (e in @e[type=armor_stand,tag=test_foreach]) {
+        count = count + 1;
+    }
+    scoreboard_set("#foreach_count", #rs, count);
+    
+    // Foreach with at @s (execute at entity position)
+    let at_count: int = 0;
+    foreach (e in @e[type=armor_stand,tag=test_foreach]) at @s {
+        // This runs at each entity's position
+        at_count = at_count + 1;
+        raw("particle minecraft:heart ~ ~1 ~ 0 0 0 0 1");
+    }
+    scoreboard_set("#foreach_at_count", #rs, at_count);
+    
+    // Cleanup
+    raw("kill @e[type=armor_stand,tag=test_foreach]");
+}

package/src/__tests__/fixtures/is-check-test.mcrs

@@ -1,20 +1,27 @@
+@load fn setup() {
+    scoreboard_add("armor_stands");
+    scoreboard_add("items");
+}
+
+// Test is-check type narrowing using armor_stands (don't despawn without players)
 fn check_types() {
-    scoreboard_set("#is_check", #players, 0);
-    scoreboard_set("#is_check", #zombies, 0);
+    scoreboard_set("#is_check", #armor_stands, 0);
+    scoreboard_set("#is_check", #items, 0);
 
-    foreach (e in @e[type=zombie,tag=is_check_target]) {
-        if (e is Player) {
-            let players: int = scoreboard_get("#is_check", #players);
-            scoreboard_set("#is_check", #players, players + 1);
+    // Test foreach with is-check on armor_stands
+    foreach (e in @e[tag=is_check_target]) {
+        if (e is ArmorStand) {
+            let count: int = scoreboard_get("#is_check", #armor_stands);
+            scoreboard_set("#is_check", #armor_stands, count + 1);
         }
 
-        if (e is Zombie) {
-            let players: int = scoreboard_get("#is_check", #players);
-            scoreboard_set("#is_check", #players, players);
+        if (e is Item) {
+            let count: int = scoreboard_get("#is_check", #items);
+            scoreboard_set("#is_check", #items, count + 1);
         }
-
-        let zombies: int = scoreboard_get("#is_check", #zombies);
-        scoreboard_set("#is_check", #zombies, zombies + 1);
-        kill(e);
     }
 }
+
+fn cleanup() {
+    raw("kill @e[tag=is_check_target]");
+}

package/src/__tests__/fixtures/match-range-test.mcrs

@@ -0,0 +1,45 @@
+// Match with range patterns test
+
+fn test_match_range() {
+    // Test score grading
+    let score: int = 85;
+    let grade: int = 0;
+    
+    match (score) {
+        0..59 => { grade = 1; }    // F
+        60..69 => { grade = 2; }   // D
+        70..79 => { grade = 3; }   // C
+        80..89 => { grade = 4; }   // B
+        90..100 => { grade = 5; }  // A
+        _ => { grade = 0; }
+    }
+    scoreboard_set("#grade", #rs, grade);
+    
+    // Test boundary values
+    let val1: int = 59;
+    let result1: int = 0;
+    match (val1) {
+        0..59 => { result1 = 1; }
+        60..100 => { result1 = 2; }
+        _ => { result1 = 0; }
+    }
+    scoreboard_set("#boundary_59", #rs, result1);
+    
+    let val2: int = 60;
+    let result2: int = 0;
+    match (val2) {
+        0..59 => { result2 = 1; }
+        60..100 => { result2 = 2; }
+        _ => { result2 = 0; }
+    }
+    scoreboard_set("#boundary_60", #rs, result2);
+    
+    // Open-ended ranges
+    let neg: int = -5;
+    let neg_result: int = 0;
+    match (neg) {
+        ..0 => { neg_result = 1; }
+        0.. => { neg_result = 2; }
+    }
+    scoreboard_set("#neg_range", #rs, neg_result);
+}

package/src/__tests__/fixtures/struct-test.mcrs

@@ -0,0 +1,34 @@
+// Struct instantiation and field access test
+
+struct Point {
+    x: int,
+    y: int,
+    z: int
+}
+
+struct Player {
+    score: int,
+    alive: bool
+}
+
+fn test_struct() {
+    // Create struct instance
+    let p: Point = { x: 10, y: 64, z: -5 };
+    
+    // Access fields
+    scoreboard_set("#struct_x", #rs, p.x);
+    scoreboard_set("#struct_y", #rs, p.y);
+    scoreboard_set("#struct_z", #rs, p.z);
+    
+    // Modify via new instance
+    let p2: Point = { x: p.x + 5, y: p.y, z: p.z * 2 };
+    scoreboard_set("#struct_x2", #rs, p2.x);
+    scoreboard_set("#struct_z2", #rs, p2.z);
+    
+    // Bool field
+    let player: Player = { score: 100, alive: true };
+    if (player.alive) {
+        scoreboard_set("#struct_alive", #rs, 1);
+    }
+    scoreboard_set("#struct_score", #rs, player.score);
+}

package/src/__tests__/lowering.test.ts

@@ -285,7 +285,7 @@ fn scan() {
 `)
       const foreachFn = ir.functions.find(fn => fn.name.includes('scan/foreach'))!
       const rawCmds = getRawCommands(foreachFn)
-      const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=player] run function test:scan/then_'))
+      const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=minecraft:player] run function test:scan/then_'))
       expect(isCheckCmd).toBeDefined()
 
       const thenFn = ir.functions.find(fn => fn.name.startsWith('scan/then_'))!
@@ -360,8 +360,8 @@ fn test() {
 
       expect(getRawCommands(mainFn)).toContain('execute as @e run function test:test/foreach_0')
       expect(thenFns).toHaveLength(2)
-      expect(rawCmds).toContain(`execute if entity @s[type=player] run function test:${playerThenFn.name}`)
-      expect(rawCmds).toContain(`execute if entity @s[type=zombie] run function test:${zombieThenFn.name}`)
+      expect(rawCmds).toContain(`execute if entity @s[type=minecraft:player] run function test:${playerThenFn.name}`)
+      expect(rawCmds).toContain(`execute if entity @s[type=minecraft:zombie] run function test:${zombieThenFn.name}`)
       expect(getRawCommands(playerThenFn).some(cmd => cmd.includes('give @s diamond 1'))).toBe(true)
       expect(getRawCommands(zombieThenFn)).toContain('kill @s')
     })