redscript-mc 1.2.30 → 2.1.0

package/dist/src/hir/lower.js

@@ -0,0 +1,399 @@
+"use strict";
+/**
+ * AST → HIR Lowering — Stage 2 of the RedScript compiler pipeline.
+ *
+ * Desugaring transforms:
+ * - for(init;cond;step) → block { init; while(cond) { body; step } }
+ * - for_range(v,start,end) → block { let v = start; while(v < end) { body; v = v + 1 } }
+ * - a += b / -= / *= / /= / %= → a = a OP b
+ * - a && b → if(a) { b } else { false }
+ * - a || b → if(a) { true } else { b }
+ * - as_block / at_block / as_at → unified execute with subcommands
+ * - All other nodes pass through with field-wise recursion
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowerToHIR = lowerToHIR;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function lowerToHIR(program) {
+    return {
+        namespace: program.namespace,
+        globals: program.globals.map(lowerGlobal),
+        functions: program.declarations.map(lowerFunction),
+        structs: program.structs.map((s) => ({
+            name: s.name,
+            fields: s.fields.map(f => ({ name: f.name, type: f.type })),
+            span: s.span,
+        })),
+        implBlocks: program.implBlocks.map((ib) => ({
+            typeName: ib.typeName,
+            methods: ib.methods.map(lowerFunction),
+            span: ib.span,
+        })),
+        enums: program.enums.map((e) => ({
+            name: e.name,
+            variants: e.variants.map(v => ({ name: v.name, value: v.value })),
+            span: e.span,
+        })),
+        consts: program.consts.map((c) => ({
+            name: c.name,
+            type: c.type,
+            value: lowerExpr(c.value),
+            span: c.span,
+        })),
+        isLibrary: program.isLibrary,
+    };
+}
+// ---------------------------------------------------------------------------
+// Functions & globals
+// ---------------------------------------------------------------------------
+function lowerGlobal(g) {
+    return {
+        name: g.name,
+        type: g.type,
+        init: lowerExpr(g.init),
+        mutable: g.mutable,
+        span: g.span,
+    };
+}
+function lowerFunction(fn) {
+    return {
+        name: fn.name,
+        typeParams: fn.typeParams,
+        params: fn.params.map(lowerParam),
+        returnType: fn.returnType,
+        decorators: fn.decorators,
+        body: lowerBlock(fn.body),
+        isLibraryFn: fn.isLibraryFn,
+        isExported: fn.isExported,
+        span: fn.span,
+    };
+}
+function lowerParam(p) {
+    return {
+        name: p.name,
+        type: p.type,
+        default: p.default ? lowerExpr(p.default) : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Blocks & statements
+// ---------------------------------------------------------------------------
+function lowerBlock(block) {
+    const result = [];
+    for (const stmt of block) {
+        const lowered = lowerStmt(stmt);
+        // lowerStmt may return an array (e.g. for → [init, while])
+        if (Array.isArray(lowered)) {
+            result.push(...lowered);
+        }
+        else {
+            result.push(lowered);
+        }
+    }
+    return result;
+}
+function lowerStmt(stmt) {
+    switch (stmt.kind) {
+        case 'let':
+            return { kind: 'let', name: stmt.name, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
+        case 'let_destruct':
+            return { kind: 'let_destruct', names: stmt.names, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
+        case 'expr':
+            return { kind: 'expr', expr: lowerExpr(stmt.expr), span: stmt.span };
+        case 'return':
+            return { kind: 'return', value: stmt.value ? lowerExpr(stmt.value) : undefined, span: stmt.span };
+        case 'break':
+            return { kind: 'break', span: stmt.span };
+        case 'continue':
+            return { kind: 'continue', span: stmt.span };
+        case 'if':
+            return {
+                kind: 'if',
+                cond: lowerExpr(stmt.cond),
+                then: lowerBlock(stmt.then),
+                else_: stmt.else_ ? lowerBlock(stmt.else_) : undefined,
+                span: stmt.span,
+            };
+        case 'while':
+            return { kind: 'while', cond: lowerExpr(stmt.cond), body: lowerBlock(stmt.body), span: stmt.span };
+        // --- Desugaring: for → while ---
+        case 'for': {
+            const stmts = [];
+            // Init
+            if (stmt.init) {
+                const init = lowerStmt(stmt.init);
+                if (Array.isArray(init))
+                    stmts.push(...init);
+                else
+                    stmts.push(init);
+            }
+            // while(cond) { body } step { step_expr }
+            const body = lowerBlock(stmt.body);
+            const step = [{ kind: 'expr', expr: lowerExpr(stmt.step), span: stmt.span }];
+            stmts.push({ kind: 'while', cond: lowerExpr(stmt.cond), body, step, span: stmt.span });
+            return stmts;
+        }
+        // --- Desugaring: for_range → let + while(cond) { body } step { v++ } ---
+        case 'for_range': {
+            const varName = stmt.varName;
+            const initStmt = {
+                kind: 'let',
+                name: varName,
+                type: { kind: 'named', name: 'int' },
+                init: lowerExpr(stmt.start),
+                span: stmt.span,
+            };
+            const body = lowerBlock(stmt.body);
+            // step: v = v + 1 (in separate step block so continue still increments)
+            const step = [{
+                    kind: 'expr',
+                    expr: {
+                        kind: 'assign',
+                        target: varName,
+                        value: {
+                            kind: 'binary',
+                            op: '+',
+                            left: { kind: 'ident', name: varName },
+                            right: { kind: 'int_lit', value: 1 },
+                        },
+                    },
+                }];
+            const whileStmt = {
+                kind: 'while',
+                cond: {
+                    kind: 'binary',
+                    op: '<',
+                    left: { kind: 'ident', name: varName },
+                    right: lowerExpr(stmt.end),
+                },
+                body,
+                step,
+                span: stmt.span,
+            };
+            return [initStmt, whileStmt];
+        }
+        case 'foreach':
+            return {
+                kind: 'foreach',
+                binding: stmt.binding,
+                iterable: lowerExpr(stmt.iterable),
+                body: lowerBlock(stmt.body),
+                executeContext: stmt.executeContext,
+                span: stmt.span,
+            };
+        case 'match':
+            return {
+                kind: 'match',
+                expr: lowerExpr(stmt.expr),
+                arms: stmt.arms.map(arm => ({
+                    pattern: arm.pattern ? lowerExpr(arm.pattern) : null,
+                    body: lowerBlock(arm.body),
+                })),
+                span: stmt.span,
+            };
+        // --- Desugaring: as_block → execute [as] ---
+        case 'as_block':
+            return {
+                kind: 'execute',
+                subcommands: [{ kind: 'as', selector: stmt.selector }],
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
+        // --- Desugaring: at_block → execute [at] ---
+        case 'at_block':
+            return {
+                kind: 'execute',
+                subcommands: [{ kind: 'at', selector: stmt.selector }],
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
+        // --- Desugaring: as_at → execute [as, at] ---
+        case 'as_at':
+            return {
+                kind: 'execute',
+                subcommands: [
+                    { kind: 'as', selector: stmt.as_sel },
+                    { kind: 'at', selector: stmt.at_sel },
+                ],
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
+        case 'execute':
+            return {
+                kind: 'execute',
+                subcommands: stmt.subcommands.map(lowerExecuteSubcommand),
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
+        case 'raw':
+            return { kind: 'raw', cmd: stmt.cmd, span: stmt.span };
+        case 'if_let_some':
+            return {
+                kind: 'if_let_some',
+                binding: stmt.binding,
+                init: lowerExpr(stmt.init),
+                then: lowerBlock(stmt.then),
+                else_: stmt.else_ ? lowerBlock(stmt.else_) : undefined,
+                span: stmt.span,
+            };
+        default: {
+            const _exhaustive = stmt;
+            throw new Error(`Unknown statement kind: ${_exhaustive.kind}`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Execute subcommands (pass-through — same shape)
+// ---------------------------------------------------------------------------
+function lowerExecuteSubcommand(sub) {
+    // All subcommand types share the same shape between AST and HIR
+    return sub;
+}
+// ---------------------------------------------------------------------------
+// Expressions
+// ---------------------------------------------------------------------------
+/** Map compound assignment operator to its base binary op */
+const COMPOUND_TO_BINOP = {
+    '+=': '+',
+    '-=': '-',
+    '*=': '*',
+    '/=': '/',
+    '%=': '%',
+};
+function lowerExpr(expr) {
+    switch (expr.kind) {
+        // --- Pass-through literals ---
+        case 'int_lit':
+        case 'float_lit':
+        case 'byte_lit':
+        case 'short_lit':
+        case 'long_lit':
+        case 'double_lit':
+        case 'bool_lit':
+        case 'str_lit':
+        case 'range_lit':
+        case 'rel_coord':
+        case 'local_coord':
+        case 'mc_name':
+        case 'blockpos':
+            return expr;
+        case 'ident':
+            return { kind: 'ident', name: expr.name, span: expr.span };
+        case 'selector':
+            return { kind: 'selector', raw: expr.raw, isSingle: expr.isSingle, sel: expr.sel, span: expr.span };
+        case 'array_lit':
+            return { kind: 'array_lit', elements: expr.elements.map(lowerExpr), span: expr.span };
+        case 'struct_lit':
+            return {
+                kind: 'struct_lit',
+                fields: expr.fields.map(f => ({ name: f.name, value: lowerExpr(f.value) })),
+                span: expr.span,
+            };
+        case 'str_interp':
+            return {
+                kind: 'str_interp',
+                parts: expr.parts.map(p => typeof p === 'string' ? p : lowerExpr(p)),
+                span: expr.span,
+            };
+        case 'f_string':
+            return { kind: 'f_string', parts: expr.parts, span: expr.span };
+        // Binary ops — && and || preserved as-is (short-circuit → control flow in MIR)
+        case 'binary':
+            return {
+                kind: 'binary',
+                op: expr.op,
+                left: lowerExpr(expr.left),
+                right: lowerExpr(expr.right),
+                span: expr.span,
+            };
+        case 'unary':
+            return { kind: 'unary', op: expr.op, operand: lowerExpr(expr.operand), span: expr.span };
+        case 'is_check':
+            return { kind: 'is_check', expr: lowerExpr(expr.expr), entityType: expr.entityType, span: expr.span };
+        // --- Desugaring: compound assignment → plain assign ---
+        case 'assign':
+            if (expr.op !== '=') {
+                const binOp = COMPOUND_TO_BINOP[expr.op];
+                return {
+                    kind: 'assign',
+                    target: expr.target,
+                    value: {
+                        kind: 'binary',
+                        op: binOp,
+                        left: { kind: 'ident', name: expr.target },
+                        right: lowerExpr(expr.value),
+                        span: expr.span,
+                    },
+                    span: expr.span,
+                };
+            }
+            return { kind: 'assign', target: expr.target, value: lowerExpr(expr.value), span: expr.span };
+        // --- Desugaring: compound member_assign → plain member_assign ---
+        case 'member_assign':
+            if (expr.op !== '=') {
+                const binOp = COMPOUND_TO_BINOP[expr.op];
+                const obj = lowerExpr(expr.obj);
+                return {
+                    kind: 'member_assign',
+                    obj,
+                    field: expr.field,
+                    value: {
+                        kind: 'binary',
+                        op: binOp,
+                        left: { kind: 'member', obj, field: expr.field },
+                        right: lowerExpr(expr.value),
+                        span: expr.span,
+                    },
+                    span: expr.span,
+                };
+            }
+            return {
+                kind: 'member_assign',
+                obj: lowerExpr(expr.obj),
+                field: expr.field,
+                value: lowerExpr(expr.value),
+                span: expr.span,
+            };
+        case 'member':
+            return { kind: 'member', obj: lowerExpr(expr.obj), field: expr.field, span: expr.span };
+        case 'index':
+            return { kind: 'index', obj: lowerExpr(expr.obj), index: lowerExpr(expr.index), span: expr.span };
+        case 'call':
+            return { kind: 'call', fn: expr.fn, args: expr.args.map(lowerExpr), typeArgs: expr.typeArgs, span: expr.span };
+        case 'invoke':
+            return { kind: 'invoke', callee: lowerExpr(expr.callee), args: expr.args.map(lowerExpr), span: expr.span };
+        case 'static_call':
+            return {
+                kind: 'static_call',
+                type: expr.type,
+                method: expr.method,
+                args: expr.args.map(lowerExpr),
+                span: expr.span,
+            };
+        case 'path_expr':
+            return { kind: 'path_expr', enumName: expr.enumName, variant: expr.variant, span: expr.span };
+        case 'tuple_lit':
+            return { kind: 'tuple_lit', elements: expr.elements.map(lowerExpr), span: expr.span };
+        case 'some_lit':
+            return { kind: 'some_lit', value: lowerExpr(expr.value), span: expr.span };
+        case 'none_lit':
+            return { kind: 'none_lit', span: expr.span };
+        case 'lambda': {
+            const body = Array.isArray(expr.body) ? lowerBlock(expr.body) : lowerExpr(expr.body);
+            return {
+                kind: 'lambda',
+                params: expr.params,
+                returnType: expr.returnType,
+                body,
+                span: expr.span,
+            };
+        }
+        default: {
+            const _exhaustive = expr;
+            throw new Error(`Unknown expression kind: ${_exhaustive.kind}`);
+        }
+    }
+}
+//# sourceMappingURL=lower.js.map

package/dist/src/hir/monomorphize.d.ts

@@ -0,0 +1,22 @@
+/**
+ * HIR Monomorphization — Phase 2c: Generic functions
+ *
+ * For each generic function `fn foo<T>(...)`, each unique instantiation
+ * `foo<int>`, `foo<float>` etc. produces a concrete copy with a mangled name.
+ *
+ * Algorithm:
+ * 1. Walk the HIR module collecting all call sites to generic functions.
+ * 2. For each unique (fnName, typeArgs) pair, clone the generic HIRFunction,
+ *    substitute all occurrences of the type params, and add to module.functions.
+ * 3. Rewrite every call site: `foo<int>(x, y)` → `foo_int(x, y)`.
+ * 4. Remove original generic function definitions from the output.
+ *
+ * Type arg → suffix mapping:
+ *   int      → "int"
+ *   float    → "float"
+ *   bool     → "bool"
+ *   string   → "string"
+ *   (others) → use struct/enum name
+ */
+import type { HIRModule } from './types';
+export declare function monomorphize(module: HIRModule): HIRModule;