redscript-mc 2.5.0 → 2.6.2

package/dist/src/__tests__/stdlib/state.test.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Tests for stdlib/state.mcrs — scoreboard-based state machine.
+ * Verifies compilation succeeds and all state machine functions are emitted.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const STATE_STDLIB = path.join(__dirname, '../../stdlib/state.mcrs');
+const stateSrc = fs.readFileSync(STATE_STDLIB, 'utf-8');
+function compileWith(extra) {
+    const result = (0, compile_1.compile)(stateSrc + '\n' + extra, { namespace: 'test' });
+    return result.files;
+}
+describe('stdlib/state.mcrs', () => {
+    // ── Compilation ──────────────────────────────────────────────────────────
+    test('compiles without errors', () => {
+        expect(() => {
+            const result = (0, compile_1.compile)(stateSrc, { namespace: 'test' });
+            expect(result.files.length).toBeGreaterThan(0);
+        }).not.toThrow();
+    });
+    // ── get_state / set_state ─────────────────────────────────────────────────
+    test('get_state function is emitted', () => {
+        const files = compileWith(`@keep fn t() -> int { return get_state(@s); }`);
+        expect(files.some(f => f.path.includes('get_state'))).toBe(true);
+    });
+    test('set_state function is emitted', () => {
+        const files = compileWith(`@keep fn t() { set_state(@s, 1); }`);
+        expect(files.some(f => f.path.includes('set_state'))).toBe(true);
+    });
+    test('get_state and set_state compile in sequence', () => {
+        const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 2);
+        return get_state(@s);
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    // ── is_state ──────────────────────────────────────────────────────────────
+    test('is_state function is emitted', () => {
+        const files = compileWith(`@keep fn t() -> int { return is_state(@s, 0); }`);
+        expect(files.some(f => f.path.includes('is_state'))).toBe(true);
+    });
+    test('is_state check after set compiles', () => {
+        const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 1);
+        return is_state(@s, 1);
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('is_state returns 0 branch compiles', () => {
+        const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 0);
+        return is_state(@s, 5);
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    // ── transition ────────────────────────────────────────────────────────────
+    test('transition function is emitted', () => {
+        const files = compileWith(`@keep fn t() -> int { return transition(@s, 0, 1); }`);
+        expect(files.some(f => f.path.includes('transition'))).toBe(true);
+    });
+    test('transition success path compiles', () => {
+        const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 0);
+        return transition(@s, 0, 1);
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('transition failure path compiles', () => {
+        const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 2);
+        return transition(@s, 0, 1);
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('chained transitions compile', () => {
+        const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 0);
+        let ok1: int = transition(@s, 0, 1);
+        let ok2: int = transition(@s, 1, 2);
+        return ok1 + ok2;
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    // ── init_state ────────────────────────────────────────────────────────────
+    test('init_state function is emitted', () => {
+        const files = compileWith(`@keep fn t() { init_state(@s, 0); }`);
+        expect(files.some(f => f.path.includes('init_state'))).toBe(true);
+    });
+    test('init_state only initialises once — second call is no-op', () => {
+        const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, -1);
+        init_state(@s, 0);
+        init_state(@s, 99);
+        return get_state(@s);
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('init_state skipped when state already set', () => {
+        const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 1);
+        init_state(@s, 0);
+        return get_state(@s);
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    // ── Combined usage ────────────────────────────────────────────────────────
+    test('full state machine lifecycle compiles', () => {
+        const files = compileWith(`
+      let STATE_IDLE: int = 0
+      let STATE_COMBAT: int = 1
+      let STATE_DEAD: int = 2
+
+      @keep fn tick() {
+        init_state(@s, STATE_IDLE);
+        let in_combat: int = is_state(@s, STATE_COMBAT);
+        if (in_combat == 1) {
+          let ok: int = transition(@s, STATE_COMBAT, STATE_DEAD);
+        }
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=state.test.js.map

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

@@ -91,21 +91,21 @@ fn test() {
             expect(result.warnings).toHaveLength(0);
         });
     });
-    describe('int/float implicit conversion checks', () => {
-        it('detects int assigned to float variable', () => {
-            // int literal assigned to float — different types
+    describe('int/fixed implicit conversion checks', () => {
+        it('detects int assigned to fixed variable', () => {
+            // int literal assigned to fixed — different types
             const errors = typeCheck(`
 fn test() {
-    let x: float = 5;
+    let x: fixed = 5;
 }
 `);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors[0].message).toContain('cannot implicitly convert int to float');
-            expect(errors[0].message).toContain('as float');
+            expect(errors[0].message).toContain('cannot implicitly convert int to fixed');
+            expect(errors[0].message).toContain('as fixed');
         });
-        it('detects float assigned to int variable', () => {
+        it('detects fixed assigned to int variable', () => {
             const errors = typeCheck(`
-fn get_f() -> float {
+fn get_f() -> fixed {
     return 3.14;
 }
 fn test() {
@@ -115,24 +115,24 @@ fn test() {
             expect(errors.length).toBeGreaterThan(0);
             expect(errors[0].message).toContain('cannot implicitly convert');
         });
-        it('detects int/float return type mismatch', () => {
+        it('detects int/fixed return type mismatch', () => {
             const errors = typeCheck(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors[0].message).toContain('cannot implicitly convert int to float');
-            expect(errors[0].message).toContain('as float');
+            expect(errors[0].message).toContain('cannot implicitly convert int to fixed');
+            expect(errors[0].message).toContain('as fixed');
         });
-        it('detects float/int return type mismatch', () => {
+        it('detects fixed/int return type mismatch', () => {
             const errors = typeCheck(`
 fn get_int() -> int {
     return 3.14;
 }
 `);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors[0].message).toContain('cannot implicitly convert float to int');
+            expect(errors[0].message).toContain('cannot implicitly convert fixed to int');
             expect(errors[0].message).toContain('as int');
         });
         it('allows int assigned to int variable', () => {
@@ -143,27 +143,27 @@ fn test() {
 `);
             expect(errors).toHaveLength(0);
         });
-        it('allows float assigned to float variable', () => {
+        it('allows fixed assigned to fixed variable', () => {
             const errors = typeCheck(`
-fn get_f() -> float {
+fn get_f() -> fixed {
     return 3.14;
 }
 fn test() {
-    let x: float = get_f();
+    let x: fixed = get_f();
 }
 `);
             expect(errors).toHaveLength(0);
         });
-        it('blocks compilation on int→float mismatch', () => {
+        it('blocks compilation on int→fixed mismatch', () => {
             expect(() => compileStrict(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `)).toThrow();
         });
-        it('int→float mismatch demoted to warning in lenient mode', () => {
+        it('int→fixed mismatch demoted to warning in lenient mode', () => {
             const result = compileLenient(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `);

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/ast/types.d.ts

@@ -12,7 +12,7 @@ export interface Span {
     endLine?: number;
     endCol?: number;
 }
-export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string';
+export type PrimitiveType = 'int' | 'bool' | 'float' | 'fixed' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string';
 export type EntityTypeName = 'entity' | 'Player' | 'Mob' | 'HostileMob' | 'PassiveMob' | 'Zombie' | 'Skeleton' | 'Creeper' | 'Spider' | 'Enderman' | 'Blaze' | 'Witch' | 'Slime' | 'ZombieVillager' | 'Husk' | 'Drowned' | 'Stray' | 'WitherSkeleton' | 'CaveSpider' | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager' | 'WanderingTrader' | 'ArmorStand' | 'Item' | 'Arrow';
 export type TypeNode = {
     kind: 'named';
@@ -263,6 +263,11 @@ export type Expr = {
 } | {
     kind: 'none_lit';
     span?: Span;
+} | {
+    kind: 'type_cast';
+    expr: Expr;
+    targetType: TypeNode;
+    span?: Span;
 };
 export type LiteralExpr = Extract<Expr, {
     kind: 'int_lit';
@@ -369,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;
@@ -425,6 +444,7 @@ export type Stmt = {
     varName: string;
     start: Expr;
     end: Expr;
+    inclusive?: boolean;
     body: Block;
     span?: Span;
 } | {
@@ -434,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/emit/compile.js

@@ -21,6 +21,7 @@ const coroutine_1 = require("../optimizer/coroutine");
 const budget_1 = require("../lir/budget");
 const mc_version_1 = require("../types/mc-version");
 const typechecker_1 = require("../typechecker");
+const types_1 = require("../events/types");
 function compile(source, options = {}) {
     const { namespace = 'redscript', filePath, generateSourceMap = false, mcVersion = mc_version_1.DEFAULT_MC_VERSION, lenient = false, includeDirs } = options;
     const warnings = [];
@@ -32,11 +33,14 @@ function compile(source, options = {}) {
     const tokens = lexer.tokenize();
     const parser = new parser_1.Parser(tokens, processedSource, filePath);
     const ast = parser.parse(namespace);
+    warnings.push(...parser.warnings);
     // Merge library imports (files with `module library;`) into AST
     for (const li of preprocessed.libraryImports ?? []) {
         const libPreprocessed = (0, compile_1.preprocessSourceWithMetadata)(li.source, { filePath: li.filePath });
         const libTokens = new lexer_1.Lexer(libPreprocessed.source, li.filePath).tokenize();
-        const libAst = new parser_1.Parser(libTokens, libPreprocessed.source, li.filePath).parse(namespace);
+        const libParser = new parser_1.Parser(libTokens, libPreprocessed.source, li.filePath);
+        const libAst = libParser.parse(namespace);
+        warnings.push(...libParser.warnings);
         for (const fn of libAst.declarations)
             fn.isLibraryFn = true;
         ast.declarations.push(...libAst.declarations);
@@ -67,6 +71,8 @@ function compile(source, options = {}) {
     {
         const checker = new typechecker_1.TypeChecker(processedSource, filePath);
         const typeErrors = checker.check(ast);
+        // Collect lint warnings (non-blocking — always added regardless of error mode)
+        warnings.push(...checker.getWarnings());
         if (typeErrors.length > 0) {
             if (lenient) {
                 for (const e of typeErrors) {
@@ -85,11 +91,12 @@ function compile(source, options = {}) {
         const hirRaw = (0, lower_1.lowerToHIR)(ast);
         // Stage 2b: Monomorphize generic functions
         const hir = (0, monomorphize_1.monomorphize)(hirRaw);
-        // Extract @tick, @load, @coroutine, and @schedule functions from HIR (before decorator info is lost)
+        // Extract @tick, @load, @coroutine, @schedule, and @on handlers from HIR (before decorator info is lost)
         const tickFunctions = [];
         const loadFunctions = [];
         const coroutineInfos = [];
         const scheduleFunctions = [];
+        const eventHandlers = new Map();
         for (const fn of hir.functions) {
             for (const dec of fn.decorators) {
                 if (dec.name === 'tick')
@@ -106,6 +113,14 @@ function compile(source, options = {}) {
                 if (dec.name === 'schedule') {
                     scheduleFunctions.push({ name: fn.name, ticks: dec.args?.ticks ?? 1 });
                 }
+                if (dec.name === 'on' && dec.args?.eventType) {
+                    const evType = dec.args.eventType;
+                    if ((0, types_1.isEventTypeName)(evType)) {
+                        if (!eventHandlers.has(evType))
+                            eventHandlers.set(evType, []);
+                        eventHandlers.get(evType).push(`${namespace}:${fn.name}`);
+                    }
+                }
             }
         }
         // Stage 3: HIR → MIR
@@ -130,8 +145,20 @@ function compile(source, options = {}) {
             }
             warnings.push(diag.message);
         }
+        // Stage 6.5: Validate LIR score_set values are in MC int32 range
+        const INT32_MAX = 2147483647;
+        const INT32_MIN = -2147483648;
+        for (const fn of lirOpt.functions) {
+            for (const instr of fn.instructions) {
+                if (instr.kind === 'score_set' && (instr.value > INT32_MAX || instr.value < INT32_MIN)) {
+                    warnings.push(`[ConstantOverflow] function '${fn.name}': ` +
+                        `scoreboard immediate ${instr.value} is outside MC int32 range [${INT32_MIN}, ${INT32_MAX}]. ` +
+                        `This indicates a constant-folding overflow bug — please report this.`);
+                }
+            }
+        }
         // Stage 7: LIR → .mcfunction
-        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion });
+        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion, eventHandlers });
         return { files, warnings, success: true };
     }
     catch (err) {

package/dist/src/emit/index.d.ts

@@ -22,5 +22,7 @@ export interface EmitOptions {
     generateSourceMap?: boolean;
     /** Target Minecraft version; controls which MC features are used in codegen */
     mcVersion?: McVersion;
+    /** Map of EventTypeName → list of fully-qualified function references for @on handlers */
+    eventHandlers?: Map<string, string[]>;
 }
 export declare function emit(module: LIRModule, options: EmitOptions): DatapackFile[];

package/dist/src/emit/index.js

@@ -74,6 +74,25 @@ function emit(module, options) {
             content: JSON.stringify({ values: tickValues }, null, 2) + '\n',
         });
     }
+    // Event handler tag files: data/rs/tags/function/on_<event>.json
+    const EVENT_TAG_NAMES = {
+        PlayerJoin: 'on_player_join',
+        PlayerDeath: 'on_player_death',
+        EntityKill: 'on_entity_kill',
+        ItemUse: 'on_item_use',
+        BlockBreak: 'on_block_break',
+    };
+    if (options.eventHandlers) {
+        for (const [evType, handlers] of options.eventHandlers) {
+            const tagName = EVENT_TAG_NAMES[evType];
+            if (tagName && handlers.length > 0) {
+                files.push({
+                    path: `data/rs/tags/function/${tagName}.json`,
+                    content: JSON.stringify({ values: handlers }, null, 2) + '\n',
+                });
+            }
+        }
+    }
     return files;
 }
 // ---------------------------------------------------------------------------
@@ -129,7 +148,7 @@ function emitInstr(instr, ns, obj, mcVersion) {
         case 'store_score_to_nbt':
             return `execute store result storage ${instr.ns} ${instr.path} ${instr.type} ${instr.scale} run scoreboard players get ${slot(instr.src)}`;
         case 'store_nbt_to_score':
-            return `execute store result score ${slot(instr.dst)} run data get storage ${instr.ns} ${instr.path} ${instr.scale}`;
+            return `execute store result score ${slot(instr.dst)} run data get storage ${instr.ns} ${instr.path} ${Number.isInteger(instr.scale) ? instr.scale.toFixed(1) : instr.scale}`;
         case 'nbt_set_literal':
             return `data modify storage ${instr.ns} ${instr.path} set value ${instr.value}`;
         case 'nbt_copy':

package/dist/src/emit/modules.js

@@ -410,8 +410,9 @@ function rewriteStmt(stmt, symbolMap) {
         case 'match':
             rewriteExpr(stmt.expr, symbolMap);
             for (const arm of stmt.arms) {
-                if (arm.pattern)
-                    rewriteExpr(arm.pattern, symbolMap);
+                // PatExpr wraps a legacy Expr that may contain symbol refs
+                if (arm.pattern.kind === 'PatExpr')
+                    rewriteExpr(arm.pattern.expr, symbolMap);
                 rewriteBlock(arm.body, symbolMap);
             }
             break;

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

@@ -12,7 +12,7 @@ export declare const EVENT_TYPES: {
     };
     readonly BlockBreak: {
         readonly tag: "rs.just_broke_block";
-        readonly params: readonly ["player: Player", "block: string"];
+        readonly params: readonly ["player: Player"];
         readonly detection: "advancement";
     };
     readonly EntityKill: {

package/dist/src/events/types.js

@@ -16,8 +16,11 @@ exports.EVENT_TYPES = {
     },
     BlockBreak: {
         tag: 'rs.just_broke_block',
-        params: ['player: Player', 'block: string'],
+        params: ['player: Player'],
         detection: 'advancement',
+        // Note: block type is NOT available as a runtime parameter — MC has no mechanism
+        // to pass event data to function tags. Use minecraft.mined:<block> scoreboard
+        // stats for per-block detection, or check the block at player's position in handler.
     },
     EntityKill: {
         tag: 'rs.just_killed',
@@ -51,7 +54,7 @@ function toTypeNode(typeName) {
     if (typeName === 'Player') {
         return { kind: 'entity', entityType: 'Player' };
     }
-    if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
+    if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'fixed' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
         return { kind: 'named', name: typeName };
     }
     return { kind: 'struct', name: typeName };

package/dist/src/hir/lower.js

@@ -46,6 +46,18 @@ function lowerToHIR(program) {
     };
 }
 // ---------------------------------------------------------------------------
+// Pattern lowering
+// ---------------------------------------------------------------------------
+function lowerMatchPattern(pat) {
+    switch (pat.kind) {
+        case 'PatSome': return pat;
+        case 'PatNone': return pat;
+        case 'PatInt': return pat;
+        case 'PatWild': return pat;
+        case 'PatExpr': return { kind: 'PatExpr', expr: lowerExpr(pat.expr) };
+    }
+}
+// ---------------------------------------------------------------------------
 // Functions & globals
 // ---------------------------------------------------------------------------
 function lowerGlobal(g) {
@@ -164,7 +176,7 @@ function lowerStmt(stmt) {
                 kind: 'while',
                 cond: {
                     kind: 'binary',
-                    op: '<',
+                    op: stmt.inclusive ? '<=' : '<',
                     left: { kind: 'ident', name: varName },
                     right: lowerExpr(stmt.end),
                 },
@@ -225,6 +237,76 @@ function lowerStmt(stmt) {
             };
             return [initStmt, whileStmt];
         }
+        // --- Desugaring: for_each → let __for_len = arr.len(); let __for_i = 0; while(__for_i < __for_len) { let item = arr[__for_i]; body; __for_i = __for_i + 1 } ---
+        case 'for_each': {
+            // Use a counter suffix to avoid collisions in nested for_each
+            const id = forEachCounter++;
+            const idxName = `__foreach_i_${id}`;
+            const lenName = `__foreach_len_${id}`;
+            const arrExpr = lowerExpr(stmt.array);
+            // let __foreach_len_N = arr.len()
+            const lenInitStmt = {
+                kind: 'let',
+                name: lenName,
+                type: { kind: 'named', name: 'int' },
+                init: {
+                    kind: 'invoke',
+                    callee: { kind: 'member', obj: arrExpr, field: 'len' },
+                    args: [],
+                },
+                span: stmt.span,
+            };
+            // let __foreach_i_N = 0
+            const idxInitStmt = {
+                kind: 'let',
+                name: idxName,
+                type: { kind: 'named', name: 'int' },
+                init: { kind: 'int_lit', value: 0 },
+                span: stmt.span,
+            };
+            // let item = arr[__foreach_i_N]
+            const bindingInit = {
+                kind: 'let',
+                name: stmt.binding,
+                type: undefined,
+                init: {
+                    kind: 'index',
+                    obj: arrExpr,
+                    index: { kind: 'ident', name: idxName },
+                },
+                span: stmt.span,
+            };
+            // __foreach_i_N = __foreach_i_N + 1
+            const stepStmt = {
+                kind: 'expr',
+                expr: {
+                    kind: 'assign',
+                    target: idxName,
+                    value: {
+                        kind: 'binary',
+                        op: '+',
+                        left: { kind: 'ident', name: idxName },
+                        right: { kind: 'int_lit', value: 1 },
+                    },
+                },
+                span: stmt.span,
+            };
+            const body = [bindingInit, ...lowerBlock(stmt.body)];
+            const step = [stepStmt];
+            const whileStmt = {
+                kind: 'while',
+                cond: {
+                    kind: 'binary',
+                    op: '<',
+                    left: { kind: 'ident', name: idxName },
+                    right: { kind: 'ident', name: lenName },
+                },
+                body,
+                step,
+                span: stmt.span,
+            };
+            return [lenInitStmt, idxInitStmt, whileStmt];
+        }
         case 'foreach':
             return {
                 kind: 'foreach',
@@ -239,7 +321,7 @@ function lowerStmt(stmt) {
                 kind: 'match',
                 expr: lowerExpr(stmt.expr),
                 arms: stmt.arms.map(arm => ({
-                    pattern: arm.pattern ? lowerExpr(arm.pattern) : null,
+                    pattern: lowerMatchPattern(arm.pattern),
                     body: lowerBlock(arm.body),
                 })),
                 span: stmt.span,
@@ -305,6 +387,8 @@ function lowerExecuteSubcommand(sub) {
 // ---------------------------------------------------------------------------
 // Expressions
 // ---------------------------------------------------------------------------
+/** Counter to generate unique variable names for for_each desugaring */
+let forEachCounter = 0;
 /** Map compound assignment operator to its base binary op */
 const COMPOUND_TO_BINOP = {
     '+=': '+',
@@ -460,6 +544,8 @@ function lowerExpr(expr) {
             return { kind: 'some_lit', value: lowerExpr(expr.value), span: expr.span };
         case 'none_lit':
             return { kind: 'none_lit', span: expr.span };
+        case 'type_cast':
+            return { kind: 'type_cast', expr: lowerExpr(expr.expr), targetType: expr.targetType, span: expr.span };
         case 'lambda': {
             const body = Array.isArray(expr.body) ? lowerBlock(expr.body) : lowerExpr(expr.body);
             return {