redscript-mc 2.0.0 → 2.1.1

package/dist/{src2 → src}/mir/lower.js

@@ -11,12 +11,21 @@ const macro_1 = require("./macro");
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
-function lowerToMIR(hir) {
+function lowerToMIR(hir, sourceFile) {
     // Build struct definitions: name → field names
     const structDefs = new Map();
     for (const s of hir.structs) {
         structDefs.set(s.name, s.fields.map(f => f.name));
     }
+    // Build enum definitions: enumName → variantName → integer value
+    const enumDefs = new Map();
+    for (const e of hir.enums) {
+        const variants = new Map();
+        for (const v of e.variants) {
+            variants.set(v.name, v.value ?? 0);
+        }
+        enumDefs.set(e.name, variants);
+    }
     // Build impl method info: typeName → methodName → { hasSelf }
     const implMethods = new Map();
     for (const ib of hir.implBlocks) {
@@ -41,13 +50,13 @@ function lowerToMIR(hir) {
     }
     const allFunctions = [];
     for (const f of hir.functions) {
-        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo);
+        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile);
         allFunctions.push(fn, ...helpers);
     }
     // Lower impl block methods
     for (const ib of hir.implBlocks) {
         for (const m of ib.methods) {
-            const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo);
+            const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile);
             allFunctions.push(fn, ...helpers);
         }
     }
@@ -61,7 +70,7 @@ function lowerToMIR(hir) {
 // Function lowering context
 // ---------------------------------------------------------------------------
 class FnContext {
-    constructor(namespace, fnName, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map()) {
+    constructor(namespace, fnName, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map()) {
         this.tempCounter = 0;
         this.blockCounter = 0;
         this.blocks = [];
@@ -71,6 +80,12 @@ class FnContext {
         this.helperFunctions = [];
         /** Struct variable tracking: varName → { typeName, fields: fieldName → temp } */
         this.structVars = new Map();
+        /** Tuple variable tracking: varName → array of element temps (index = slot) */
+        this.tupleVars = new Map();
+        /** Current source location (set during statement lowering) */
+        this.currentSourceLoc = undefined;
+        /** Source file path for the module being compiled */
+        this.sourceFile = undefined;
         this.namespace = namespace;
         this.fnName = fnName;
         this.structDefs = structDefs;
@@ -78,6 +93,7 @@ class FnContext {
         this.macroInfo = macroInfo;
         this.fnParamInfo = fnParamInfo;
         this.currentMacroParams = macroInfo.get(fnName)?.macroParams ?? new Set();
+        this.enumDefs = enumDefs;
         const entry = this.makeBlock('entry');
         this.currentBlock = entry;
     }
@@ -98,9 +114,15 @@ class FnContext {
         return this.makeBlock(prefix ? `${prefix}_${this.blockCounter++}` : undefined);
     }
     emit(instr) {
+        if (this.currentSourceLoc && !instr.sourceLoc) {
+            instr.sourceLoc = this.currentSourceLoc;
+        }
         this.currentBlock.instrs.push(instr);
     }
     terminate(term) {
+        if (this.currentSourceLoc && !term.sourceLoc) {
+            term.sourceLoc = this.currentSourceLoc;
+        }
         this.currentBlock.term = term;
     }
     switchTo(block) {
@@ -128,8 +150,9 @@ class FnContext {
 // ---------------------------------------------------------------------------
 // Function lowering
 // ---------------------------------------------------------------------------
-function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map()) {
-    const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo);
+function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile) {
+    const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs);
+    ctx.sourceFile = sourceFile;
     const fnMacroInfo = macroInfo.get(fn.name);
     // Create temps for parameters
     const params = fn.params.map(p => {
@@ -161,9 +184,10 @@ function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new
     };
     return { fn: result, helpers: ctx.helperFunctions };
 }
-function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = new Map(), fnParamInfo = new Map()) {
+function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile) {
     const fnName = `${typeName}::${method.name}`;
-    const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo);
+    const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs);
+    ctx.sourceFile = sourceFile;
     const fields = structDefs.get(typeName) ?? [];
     const hasSelf = method.params.length > 0 && method.params[0].name === 'self';
     const params = [];
@@ -262,9 +286,33 @@ function lowerBlock(stmts, ctx, scope) {
     }
 }
 function lowerStmt(stmt, ctx, scope) {
+    // Propagate source location from HIR statement span
+    if (stmt.span && ctx.sourceFile) {
+        ctx.currentSourceLoc = { file: ctx.sourceFile, line: stmt.span.line, col: stmt.span.col };
+    }
     switch (stmt.kind) {
         case 'let': {
-            if (stmt.init.kind === 'struct_lit') {
+            if (stmt.init.kind === 'some_lit') {
+                // Some(expr) — create option struct vars: has=1, val=expr
+                // Use __opt_ prefix so DCE treats these as side-effectful scoreboard writes
+                const hasTemp = `__opt_${stmt.name}_has`;
+                const valTemp = `__opt_${stmt.name}_val`;
+                ctx.emit({ kind: 'const', dst: hasTemp, value: 1 });
+                const valOp = lowerExpr(stmt.init.value, ctx, scope);
+                ctx.emit({ kind: 'copy', dst: valTemp, src: valOp });
+                const fieldTemps = new Map([['has', hasTemp], ['val', valTemp]]);
+                ctx.structVars.set(stmt.name, { typeName: '__option', fields: fieldTemps });
+            }
+            else if (stmt.init.kind === 'none_lit') {
+                // None — create option struct vars: has=0, val=0
+                const hasTemp = `__opt_${stmt.name}_has`;
+                const valTemp = `__opt_${stmt.name}_val`;
+                ctx.emit({ kind: 'const', dst: hasTemp, value: 0 });
+                ctx.emit({ kind: 'const', dst: valTemp, value: 0 });
+                const fieldTemps = new Map([['has', hasTemp], ['val', valTemp]]);
+                ctx.structVars.set(stmt.name, { typeName: '__option', fields: fieldTemps });
+            }
+            else if (stmt.init.kind === 'struct_lit') {
                 // Struct literal: create per-field temps
                 const typeName = (stmt.type?.kind === 'struct') ? stmt.type.name : '__anon';
                 const fieldTemps = new Map();
@@ -276,6 +324,16 @@ function lowerStmt(stmt, ctx, scope) {
                 }
                 ctx.structVars.set(stmt.name, { typeName, fields: fieldTemps });
             }
+            else if (stmt.type?.kind === 'option') {
+                // Option<T>-typed let with function call result — use __rf_has/__rf_val convention
+                lowerExpr(stmt.init, ctx, scope);
+                const hasTemp = `__opt_${stmt.name}_has`;
+                const valTemp = `__opt_${stmt.name}_val`;
+                ctx.emit({ kind: 'copy', dst: hasTemp, src: { kind: 'temp', name: '__rf_has' } });
+                ctx.emit({ kind: 'copy', dst: valTemp, src: { kind: 'temp', name: '__rf_val' } });
+                const fieldTemps = new Map([['has', hasTemp], ['val', valTemp]]);
+                ctx.structVars.set(stmt.name, { typeName: '__option', fields: fieldTemps });
+            }
             else if (stmt.type?.kind === 'struct') {
                 // Struct-typed let with non-literal init (e.g., call returning struct)
                 const fields = ctx.structDefs.get(stmt.type.name);
@@ -305,12 +363,74 @@ function lowerStmt(stmt, ctx, scope) {
             }
             break;
         }
+        case 'let_destruct': {
+            // Tuple destructuring: let (a, b, c) = expr
+            const n = stmt.names.length;
+            if (stmt.init.kind === 'tuple_lit') {
+                // Direct tuple literal: evaluate each element into its own temp
+                const elemTemps = [];
+                for (let i = 0; i < stmt.init.elements.length && i < n; i++) {
+                    const val = lowerExpr(stmt.init.elements[i], ctx, scope);
+                    const t = ctx.freshTemp();
+                    ctx.emit({ kind: 'copy', dst: t, src: val });
+                    elemTemps.push(t);
+                    scope.set(stmt.names[i], t);
+                }
+            }
+            else if (stmt.init.kind === 'ident') {
+                // Could be referencing a known tuple var
+                const tv = ctx.tupleVars.get(stmt.init.name);
+                if (tv) {
+                    for (let i = 0; i < n && i < tv.length; i++) {
+                        scope.set(stmt.names[i], tv[i]);
+                    }
+                    break;
+                }
+                // Otherwise treat as a call result stored in __rf_ slots
+                lowerExpr(stmt.init, ctx, scope);
+                const elemTemps = [];
+                for (let i = 0; i < n; i++) {
+                    const t = ctx.freshTemp();
+                    ctx.emit({ kind: 'copy', dst: t, src: { kind: 'temp', name: `__rf_${i}` } });
+                    elemTemps.push(t);
+                    scope.set(stmt.names[i], t);
+                }
+                // Register as tuple var so it can be passed around
+                const varName = stmt.names.join('_') + '_tup';
+                ctx.tupleVars.set(varName, elemTemps);
+            }
+            else {
+                // General expression (e.g. function call) — evaluate, read __rf_ slots
+                lowerExpr(stmt.init, ctx, scope);
+                const elemTemps = [];
+                for (let i = 0; i < n; i++) {
+                    const t = ctx.freshTemp();
+                    ctx.emit({ kind: 'copy', dst: t, src: { kind: 'temp', name: `__rf_${i}` } });
+                    elemTemps.push(t);
+                    scope.set(stmt.names[i], t);
+                }
+            }
+            break;
+        }
         case 'expr': {
             lowerExpr(stmt.expr, ctx, scope);
             break;
         }
         case 'return': {
-            if (stmt.value?.kind === 'struct_lit') {
+            if (stmt.value?.kind === 'some_lit') {
+                // Option return: Some(expr) → set __rf_has=1, __rf_val=expr
+                const valOp = lowerExpr(stmt.value.value, ctx, scope);
+                ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'const', value: 1 } });
+                ctx.emit({ kind: 'copy', dst: '__rf_val', src: valOp });
+                ctx.terminate({ kind: 'return', value: null });
+            }
+            else if (stmt.value?.kind === 'none_lit') {
+                // Option return: None → set __rf_has=0, __rf_val=0
+                ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'const', value: 0 } });
+                ctx.emit({ kind: 'copy', dst: '__rf_val', src: { kind: 'const', value: 0 } });
+                ctx.terminate({ kind: 'return', value: null });
+            }
+            else if (stmt.value?.kind === 'struct_lit') {
                 // Struct return — copy each field to return field slots
                 for (const field of stmt.value.fields) {
                     const val = lowerExpr(field.value, ctx, scope);
@@ -318,6 +438,29 @@ function lowerStmt(stmt, ctx, scope) {
                 }
                 ctx.terminate({ kind: 'return', value: null });
             }
+            else if (stmt.value?.kind === 'tuple_lit') {
+                // Tuple return — copy each element to __rf_0, __rf_1, ...
+                for (let i = 0; i < stmt.value.elements.length; i++) {
+                    const val = lowerExpr(stmt.value.elements[i], ctx, scope);
+                    ctx.emit({ kind: 'copy', dst: `__rf_${i}`, src: val });
+                }
+                ctx.terminate({ kind: 'return', value: null });
+            }
+            else if (stmt.value?.kind === 'ident') {
+                // Check if returning an option struct var
+                const sv = ctx.structVars.get(stmt.value.name);
+                if (sv && sv.typeName === '__option') {
+                    const hasT = sv.fields.get('has');
+                    const valT = sv.fields.get('val');
+                    ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'temp', name: hasT } });
+                    ctx.emit({ kind: 'copy', dst: '__rf_val', src: { kind: 'temp', name: valT } });
+                    ctx.terminate({ kind: 'return', value: null });
+                }
+                else {
+                    const val = lowerExpr(stmt.value, ctx, scope);
+                    ctx.terminate({ kind: 'return', value: val });
+                }
+            }
             else {
                 const val = stmt.value ? lowerExpr(stmt.value, ctx, scope) : null;
                 ctx.terminate({ kind: 'return', value: val });
@@ -501,6 +644,56 @@ function lowerStmt(stmt, ctx, scope) {
             ctx.emit({ kind: 'call', dst: null, fn: `__raw:${stmt.cmd}`, args: [] });
             break;
         }
+        case 'if_let_some': {
+            // if let Some(x) = opt { ... }
+            // Lower: check opt.has, if 1 then bind x = opt.val and run then-block
+            const sv = (() => {
+                if (stmt.init.kind === 'ident')
+                    return ctx.structVars.get(stmt.init.name);
+                return undefined;
+            })();
+            let hasOp;
+            let valTemp;
+            if (sv && sv.typeName === '__option') {
+                const hasT = sv.fields.get('has');
+                const valT = sv.fields.get('val');
+                hasOp = { kind: 'temp', name: hasT };
+                valTemp = valT;
+            }
+            else {
+                // General: evaluate init (e.g. function call returning option via __rf_has/__rf_val)
+                lowerExpr(stmt.init, ctx, scope);
+                const hasT = ctx.freshTemp();
+                const valT = ctx.freshTemp();
+                ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } });
+                ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } });
+                hasOp = { kind: 'temp', name: hasT };
+                valTemp = valT;
+            }
+            const thenBlock = ctx.newBlock('ifl_then');
+            const mergeBlock = ctx.newBlock('ifl_merge');
+            const elseBlock = stmt.else_ ? ctx.newBlock('ifl_else') : mergeBlock;
+            ctx.terminate({ kind: 'branch', cond: hasOp, then: thenBlock.id, else: elseBlock.id });
+            // Then branch: bind x = val temp
+            ctx.switchTo(thenBlock);
+            const thenScope = new Map(scope);
+            if (valTemp)
+                thenScope.set(stmt.binding, valTemp);
+            lowerBlock(stmt.then, ctx, thenScope);
+            if (isPlaceholderTerm(ctx.current().term)) {
+                ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+            }
+            // Else branch
+            if (stmt.else_) {
+                ctx.switchTo(elseBlock);
+                lowerBlock(stmt.else_, ctx, new Map(scope));
+                if (isPlaceholderTerm(ctx.current().term)) {
+                    ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+                }
+            }
+            ctx.switchTo(mergeBlock);
+            break;
+        }
         default: {
             const _exhaustive = stmt;
             throw new Error(`Unknown HIR statement kind: ${_exhaustive.kind}`);
@@ -630,7 +823,20 @@ function lowerExpr(expr, ctx, scope) {
             }
             return val;
         }
+        case 'path_expr': {
+            // Enum variant access: Phase::Idle → integer constant
+            const variants = ctx.enumDefs.get(expr.enumName);
+            const value = variants?.get(expr.variant) ?? 0;
+            return { kind: 'const', value };
+        }
         case 'member': {
+            // Enum variant access via dot syntax: Phase.Idle → integer constant
+            if (expr.obj.kind === 'ident') {
+                const enumVariants = ctx.enumDefs.get(expr.obj.name);
+                if (enumVariants && enumVariants.has(expr.field)) {
+                    return { kind: 'const', value: enumVariants.get(expr.field) };
+                }
+            }
             // Struct field access: v.x → return v's x temp
             if (expr.obj.kind === 'ident') {
                 const sv = ctx.structVars.get(expr.obj.name);
@@ -744,6 +950,34 @@ function lowerExpr(expr, ctx, scope) {
             ctx.emit({ kind: 'call', dst: t, fn: `${expr.type}::${expr.method}`, args });
             return { kind: 'temp', name: t };
         }
+        case 'tuple_lit': {
+            // Inline tuple literal as expression: store elements into __rf_ slots and return a dummy temp
+            // This happens when a tuple literal appears as an expression (e.g., passed to a function)
+            for (let i = 0; i < expr.elements.length; i++) {
+                const val = lowerExpr(expr.elements[i], ctx, scope);
+                ctx.emit({ kind: 'copy', dst: `__rf_${i}`, src: val });
+            }
+            const t = ctx.freshTemp();
+            ctx.emit({ kind: 'const', dst: t, value: 0 });
+            return { kind: 'temp', name: t };
+        }
+        case 'some_lit': {
+            // Some(expr) in expression context: store has=1,val into __rf_has/__rf_val slots
+            const valOp = lowerExpr(expr.value, ctx, scope);
+            ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'const', value: 1 } });
+            ctx.emit({ kind: 'copy', dst: '__rf_val', src: valOp });
+            const t = ctx.freshTemp();
+            ctx.emit({ kind: 'const', dst: t, value: 1 });
+            return { kind: 'temp', name: t };
+        }
+        case 'none_lit': {
+            // None in expression context: store has=0,val=0 into __rf_has/__rf_val slots
+            ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'const', value: 0 } });
+            ctx.emit({ kind: 'copy', dst: '__rf_val', src: { kind: 'const', value: 0 } });
+            const t = ctx.freshTemp();
+            ctx.emit({ kind: 'const', dst: t, value: 0 });
+            return { kind: 'temp', name: t };
+        }
         default: {
             const _exhaustive = expr;
             throw new Error(`Unknown HIR expression kind: ${_exhaustive.kind}`);

package/dist/{src2 → src}/mir/types.d.ts

@@ -7,6 +7,11 @@
  * Spec: docs/compiler-pipeline-redesign.md § "MIR Instruction Set"
  */
 export type Temp = string;
+export interface SourceLoc {
+    file: string;
+    line: number;
+    col: number;
+}
 export type Operand = {
     kind: 'temp';
     name: Temp;
@@ -59,7 +64,10 @@ export type ExecuteSubcmd = {
     score: string;
     range: string;
 };
-export type MIRInstr = {
+export type MIRInstrBase = {
+    sourceLoc?: SourceLoc;
+};
+export type MIRInstr = MIRInstrBase & ({
     kind: 'const';
     dst: Temp;
     value: number;
@@ -159,7 +167,7 @@ export type MIRInstr = {
 } | {
     kind: 'return';
     value: Operand | null;
-};
+});
 export interface MIRBlock {
     id: BlockId;
     instrs: MIRInstr[];

package/dist/src/optimizer/coroutine.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Coroutine Transform — MIR module-level pass.
+ *
+ * Transforms functions annotated with @coroutine(batch=N, onDone=fn) into
+ * tick-spread state machines. Each loop back-edge becomes a yield point,
+ * and the function is split into continuation functions dispatched by a
+ * @tick function via a pc (program counter) scoreboard slot.
+ *
+ * Algorithm:
+ *   1. Compute dominator tree → find back edges (yield points)
+ *   2. Backward liveness analysis at yield points
+ *   3. Split CFG into continuations at yield points
+ *   4. Promote live variables to persistent scoreboard slots
+ *   5. Generate @tick dispatcher function
+ *
+ * Spec: docs/compiler-pipeline-redesign.md § "Coroutine Transform"
+ */
+import type { MIRModule } from '../mir/types';
+export interface CoroutineInfo {
+    fnName: string;
+    batch: number;
+    onDone?: string;
+}
+export interface CoroutineResult {
+    module: MIRModule;
+    /** Names of generated @tick dispatcher functions (caller must add to tick list). */
+    generatedTickFunctions: string[];
+}
+/**
+ * Apply the coroutine transform to all functions in `infos`.
+ * Returns a new module with continuations + dispatchers injected,
+ * and the original function replaced with initialization code.
+ */
+export declare function coroutineTransform(mod: MIRModule, infos: CoroutineInfo[]): CoroutineResult;