redscript-mc 2.0.0 → 2.1.0

package/dist/{src2 → src}/emit/index.js

@@ -7,6 +7,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emit = emit;
+const sourcemap_1 = require("./sourcemap");
+const mc_version_1 = require("../types/mc-version");
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -14,7 +16,10 @@ function emit(module, options) {
     const { namespace } = options;
     const tickFns = options.tickFunctions ?? [];
     const loadFns = options.loadFunctions ?? [];
+    const scheduleFns = options.scheduleFunctions ?? [];
     const objective = module.objective;
+    const genSourceMap = options.generateSourceMap ?? false;
+    const mcVersion = options.mcVersion ?? mc_version_1.DEFAULT_MC_VERSION;
     const files = [];
     // pack.mcmeta
     files.push({
@@ -31,9 +36,27 @@ function emit(module, options) {
     });
     // Each LIR function → .mcfunction file
     for (const fn of module.functions) {
-        const lines = emitFunction(fn, namespace, objective);
         const fnPath = fnNameToPath(fn.name, namespace);
-        files.push({ path: fnPath, content: lines.join('\n') + '\n' });
+        if (genSourceMap) {
+            const builder = new sourcemap_1.SourceMapBuilder(fnPath);
+            const lines = emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion);
+            files.push({ path: fnPath, content: lines.join('\n') + '\n' });
+            const map = builder.build();
+            if (map) {
+                files.push({ path: (0, sourcemap_1.sourceMapPath)(fnPath), content: (0, sourcemap_1.serializeSourceMap)(map) });
+            }
+        }
+        else {
+            const lines = emitFunction(fn, namespace, objective, mcVersion);
+            files.push({ path: fnPath, content: lines.join('\n') + '\n' });
+        }
+    }
+    // @schedule wrapper functions: _schedule_xxx → schedule function ns:xxx Nt
+    for (const { name, ticks } of scheduleFns) {
+        files.push({
+            path: `data/${namespace}/function/_schedule_${name}.mcfunction`,
+            content: `schedule function ${namespace}:${name} ${ticks}t\n`,
+        });
     }
     // Tag files for tick/load
     if (loadFns.length > 0 || true) {
@@ -56,10 +79,18 @@ function emit(module, options) {
 // ---------------------------------------------------------------------------
 // Function emission
 // ---------------------------------------------------------------------------
-function emitFunction(fn, namespace, objective) {
+function emitFunction(fn, namespace, objective, mcVersion) {
+    const lines = [];
+    for (const instr of fn.instructions) {
+        lines.push(emitInstr(instr, namespace, objective, mcVersion));
+    }
+    return lines;
+}
+function emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion) {
     const lines = [];
     for (const instr of fn.instructions) {
-        lines.push(emitInstr(instr, namespace, objective));
+        lines.push(emitInstr(instr, namespace, objective, mcVersion));
+        builder.addLine(instr.sourceLoc);
     }
     return lines;
 }
@@ -71,7 +102,7 @@ function fnNameToPath(name, namespace) {
 // ---------------------------------------------------------------------------
 // Instruction emission
 // ---------------------------------------------------------------------------
-function emitInstr(instr, ns, obj) {
+function emitInstr(instr, ns, obj, mcVersion) {
     switch (instr.kind) {
         case 'score_set':
             return `scoreboard players set ${slot(instr.dst)} ${instr.value}`;
@@ -94,7 +125,7 @@ function emitInstr(instr, ns, obj) {
         case 'score_swap':
             return `scoreboard players operation ${slot(instr.a)} >< ${slot(instr.b)}`;
         case 'store_cmd_to_score':
-            return `execute store result score ${slot(instr.dst)} run ${emitInstr(instr.cmd, ns, obj)}`;
+            return `execute store result score ${slot(instr.dst)} run ${emitInstr(instr.cmd, 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':
@@ -106,7 +137,11 @@ function emitInstr(instr, ns, obj) {
         case 'call':
             return `function ${instr.fn}`;
         case 'call_macro':
-            return `function ${instr.fn} with storage ${instr.storage}`;
+            if (mcVersion >= mc_version_1.McVersion.v1_20_2) {
+                return `function ${instr.fn} with storage ${instr.storage}`;
+            }
+            // Pre-1.20.2: macros not supported; call function directly (args in storage are ignored)
+            return `function ${instr.fn}`;
         case 'call_if_matches':
             return `execute if score ${slot(instr.slot)} matches ${instr.range} run function ${instr.fn}`;
         case 'call_unless_matches':
@@ -122,7 +157,13 @@ function emitInstr(instr, ns, obj) {
         case 'return_value':
             return `scoreboard players operation $ret ${instr.slot.obj} = ${slot(instr.slot)}`;
         case 'macro_line':
-            return `$${instr.template}`;
+            if (mcVersion >= mc_version_1.McVersion.v1_20_2) {
+                return `$${instr.template}`;
+            }
+            // Pre-1.20.2: function macros not available. Emit as a plain command with
+            // $(param) placeholders replaced by storage reads via data get (best-effort
+            // compat for string/id params; numeric coords will not be dynamic).
+            return macroLineCompat(instr.template);
         case 'raw':
             return instr.cmd;
     }
@@ -143,6 +184,16 @@ function cmpToMC(op) {
         case 'ge': return '>=';
     }
 }
+/**
+ * Pre-1.20.2 compat: emit a macro template as a plain command.
+ * $(param) placeholders are replaced with `storage rs:macro_args <param>` data-get
+ * expressions for string/id values, or left as literal "0" for coordinates.
+ * This is best-effort — dynamic numeric positions cannot be truly emulated.
+ */
+function macroLineCompat(template) {
+    // Replace $(param) with data-get-style substitution marker
+    return template.replace(/\$\((\w+)\)/g, (_m, p) => `{storage:rs:macro_args,path:${p}}`);
+}
 function emitSubcmd(sub) {
     switch (sub.kind) {
         case 'as':

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

@@ -0,0 +1,29 @@
+/**
+ * Phase 5b — Multi-Module Compilation
+ *
+ * Compiles multiple .mcrs files that use `module <name>;` / `import <mod>::<sym>;`
+ * into a single datapack with namespace-isolated scoreboards and correct cross-module
+ * function paths.
+ *
+ * Design:
+ * - Each module gets its own scoreboard objective: `__${namespace}_${moduleName}`
+ * - Cross-module function calls are emitted as `${namespace}:${moduleName}/${fnName}`
+ * - DCE: exported-but-never-imported functions are stripped from the output
+ * - Circular imports are detected and rejected
+ */
+import { type DatapackFile } from './index';
+export interface ModuleInput {
+    /** Module name (must match the `module <name>;` declaration in source, or be inferred) */
+    name: string;
+    source: string;
+    filePath?: string;
+}
+export interface CompileModulesOptions {
+    /** Datapack namespace (e.g. "mypack") */
+    namespace?: string;
+}
+export interface CompileModulesResult {
+    files: DatapackFile[];
+    warnings: string[];
+}
+export declare function compileModules(modules: ModuleInput[], options?: CompileModulesOptions): CompileModulesResult;

package/dist/src/emit/modules.js

@@ -0,0 +1,492 @@
+"use strict";
+/**
+ * Phase 5b — Multi-Module Compilation
+ *
+ * Compiles multiple .mcrs files that use `module <name>;` / `import <mod>::<sym>;`
+ * into a single datapack with namespace-isolated scoreboards and correct cross-module
+ * function paths.
+ *
+ * Design:
+ * - Each module gets its own scoreboard objective: `__${namespace}_${moduleName}`
+ * - Cross-module function calls are emitted as `${namespace}:${moduleName}/${fnName}`
+ * - DCE: exported-but-never-imported functions are stripped from the output
+ * - Circular imports are detected and rejected
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileModules = compileModules;
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const diagnostics_1 = require("../diagnostics");
+const lower_1 = require("../hir/lower");
+const monomorphize_1 = require("../hir/monomorphize");
+const lower_2 = require("../mir/lower");
+const pipeline_1 = require("../optimizer/pipeline");
+const lower_3 = require("../lir/lower");
+const pipeline_2 = require("../optimizer/lir/pipeline");
+const index_1 = require("./index");
+const coroutine_1 = require("../optimizer/coroutine");
+function compileModules(modules, options = {}) {
+    const namespace = options.namespace ?? 'redscript';
+    const warnings = [];
+    if (modules.length === 0) {
+        throw new diagnostics_1.DiagnosticError('LoweringError', 'No modules provided', { line: 1, col: 1 });
+    }
+    // -------------------------------------------------------------------------
+    // Step 1: Parse all modules
+    // -------------------------------------------------------------------------
+    const parsedModules = new Map(); // moduleName → AST
+    for (const mod of modules) {
+        const lexer = new lexer_1.Lexer(mod.source, mod.filePath);
+        const tokens = lexer.tokenize();
+        const parser = new parser_1.Parser(tokens, mod.source, mod.filePath);
+        const ast = parser.parse(namespace);
+        // Verify declared module name matches provided name
+        const declaredName = ast.moduleName;
+        if (declaredName && declaredName !== mod.name) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Module declares name '${declaredName}' but was registered as '${mod.name}'`, { file: mod.filePath, line: 1, col: 1 });
+        }
+        parsedModules.set(mod.name, ast);
+    }
+    // -------------------------------------------------------------------------
+    // Step 2: Build export tables and validate imports
+    // -------------------------------------------------------------------------
+    // moduleName → set of exported function names
+    const exportTable = new Map();
+    for (const [modName, ast] of parsedModules) {
+        const exports = new Set();
+        for (const fn of ast.declarations) {
+            if (fn.isExported)
+                exports.add(fn.name);
+        }
+        exportTable.set(modName, exports);
+    }
+    // -------------------------------------------------------------------------
+    // Step 3: Circular import detection
+    // -------------------------------------------------------------------------
+    detectCircularImports(parsedModules);
+    // -------------------------------------------------------------------------
+    // Step 4: Build import resolution table per module
+    // importMap: moduleName → { symbolName → qualifiedName (e.g. "math/sin") }
+    // -------------------------------------------------------------------------
+    const importMap = new Map();
+    for (const [modName, ast] of parsedModules) {
+        const resolved = new Map();
+        for (const imp of ast.imports) {
+            const sourceExports = exportTable.get(imp.moduleName);
+            if (!sourceExports) {
+                throw new diagnostics_1.DiagnosticError('LoweringError', `Module '${imp.moduleName}' not found (imported in '${modName}')`, { file: ast.namespace, line: 1, col: 1 });
+            }
+            if (imp.symbol === '*') {
+                // Wildcard: import all exports
+                for (const sym of sourceExports) {
+                    resolved.set(sym, `${imp.moduleName}/${sym}`);
+                }
+            }
+            else {
+                if (!sourceExports.has(imp.symbol)) {
+                    throw new diagnostics_1.DiagnosticError('LoweringError', `Module '${imp.moduleName}' does not export '${imp.symbol}'`, { line: 1, col: 1 });
+                }
+                resolved.set(imp.symbol, `${imp.moduleName}/${imp.symbol}`);
+            }
+        }
+        importMap.set(modName, resolved);
+    }
+    // -------------------------------------------------------------------------
+    // Step 5: Compute which exported symbols are actually used (for cross-module DCE)
+    // usedExports: moduleName → set of exported fn names that are imported somewhere
+    // -------------------------------------------------------------------------
+    const usedExports = new Map();
+    for (const modName of parsedModules.keys()) {
+        usedExports.set(modName, new Set());
+    }
+    for (const ast of parsedModules.values()) {
+        for (const imp of ast.imports) {
+            const used = usedExports.get(imp.moduleName);
+            if (!used)
+                continue;
+            if (imp.symbol === '*') {
+                const exports = exportTable.get(imp.moduleName);
+                if (exports)
+                    for (const s of exports)
+                        used.add(s);
+            }
+            else {
+                used.add(imp.symbol);
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Step 6: Compile each module
+    // -------------------------------------------------------------------------
+    const allFiles = [];
+    // Track library-eligible file paths for cross-module DCE
+    const libraryFilePaths = new Set();
+    let packMetaEmitted = false;
+    for (const mod of modules) {
+        const ast = parsedModules.get(mod.name);
+        const symbolMap = importMap.get(mod.name) ?? new Map();
+        const isNamed = !!ast.moduleName;
+        // Rewrite call sites in AST: imported symbol names → qualified names
+        if (symbolMap.size > 0) {
+            rewriteCallsInProgram(ast, symbolMap);
+        }
+        // For named modules: prefix all function definitions with `${moduleName}/`
+        // so they emit to `${namespace}:${moduleName}/${fnName}.mcfunction`
+        // Track which exported functions are not imported anywhere (for cross-module DCE)
+        const unusedExportedFns = new Set();
+        if (isNamed) {
+            const used = usedExports.get(mod.name) ?? new Set();
+            for (const fn of ast.declarations) {
+                // Prefix function name
+                fn.name = `${mod.name}/${fn.name}`;
+                // Functions not imported by anyone are library-eligible (DCE)
+                const baseName = fn.name.split('/').pop();
+                if (fn.isExported && !used.has(baseName)) {
+                    unusedExportedFns.add(fn.name);
+                }
+            }
+        }
+        // Determine scoreboard objective
+        // Named module: `__${namespace}_${moduleName}`, anonymous: `__${namespace}`
+        const objective = isNamed ? `__${namespace}_${mod.name}` : `__${namespace}`;
+        // Run the pipeline
+        const modFiles = compileSingleModule(ast, namespace, objective, isNamed ? mod.name : undefined, mod.filePath);
+        warnings.push(...modFiles.warnings);
+        // Record library-eligible file paths (only if there are multiple modules — single module = library author)
+        if (modules.length > 1) {
+            for (const fnName of unusedExportedFns) {
+                // fnName is like "math/unused" → file path "data/<ns>/function/math/unused.mcfunction"
+                libraryFilePaths.add(`data/${namespace}/function/${fnName}.mcfunction`);
+            }
+        }
+        // Merge files, emitting pack.mcmeta only once
+        for (const file of modFiles.files) {
+            if (file.path === 'pack.mcmeta') {
+                if (!packMetaEmitted) {
+                    allFiles.push(file);
+                    packMetaEmitted = true;
+                }
+                continue;
+            }
+            // Merge load.json tag values
+            if (file.path === 'data/minecraft/tags/function/load.json') {
+                mergeTagFile(allFiles, file);
+                continue;
+            }
+            // Merge tick.json tag values
+            if (file.path === 'data/minecraft/tags/function/tick.json') {
+                mergeTagFile(allFiles, file);
+                continue;
+            }
+            allFiles.push(file);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Step 7: Cross-module DCE — remove unreachable library-eligible functions
+    // -------------------------------------------------------------------------
+    const finalFiles = crossModuleDCE(allFiles, libraryFilePaths, namespace);
+    return { files: finalFiles, warnings };
+}
+/**
+ * File-level cross-module DCE.
+ *
+ * After all module files are emitted, prune .mcfunction files that:
+ * 1. Correspond to exported-but-unimported functions (tracked in `libraryPaths`)
+ * 2. Are not reachable (directly or transitively) from any non-library entry file
+ *
+ * The reachability is computed by scanning `function <ns>:<path>` calls in
+ * every .mcfunction file.
+ */
+function crossModuleDCE(files, libraryPaths, // file paths (e.g. "data/ns/function/math/unused.mcfunction")
+namespace) {
+    if (libraryPaths.size === 0)
+        return files;
+    // Build a map: fnPath (e.g. "ns:math/add") → file path
+    const fnPathToFilePath = new Map();
+    for (const file of files) {
+        const m = file.path.match(/^data\/([^/]+)\/function\/(.+)\.mcfunction$/);
+        if (m) {
+            fnPathToFilePath.set(`${m[1]}:${m[2]}`, file.path);
+        }
+    }
+    // Build call graph: filePath → set of called fnPaths (namespace:path)
+    const callGraph = new Map();
+    const callPattern = /\bfunction\s+([\w\-]+:[\w\-./]+)/g;
+    for (const file of files) {
+        if (!file.path.endsWith('.mcfunction'))
+            continue;
+        const called = new Set();
+        let match;
+        callPattern.lastIndex = 0;
+        while ((match = callPattern.exec(file.content)) !== null) {
+            called.add(match[1]);
+        }
+        callGraph.set(file.path, called);
+    }
+    // BFS from non-library entry files
+    const reachableFiles = new Set();
+    const queue = [];
+    for (const file of files) {
+        if (!file.path.endsWith('.mcfunction'))
+            continue;
+        if (!libraryPaths.has(file.path)) {
+            // Non-library file: it's an entry point
+            queue.push(file.path);
+            reachableFiles.add(file.path);
+        }
+    }
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const called = callGraph.get(current) ?? new Set();
+        for (const fnPath of called) {
+            const filePath = fnPathToFilePath.get(fnPath);
+            if (filePath && !reachableFiles.has(filePath)) {
+                reachableFiles.add(filePath);
+                queue.push(filePath);
+            }
+        }
+    }
+    // Filter out unreachable library files
+    return files.filter(file => {
+        if (!libraryPaths.has(file.path))
+            return true; // non-library: always keep
+        return reachableFiles.has(file.path); // library: keep only if reachable
+    });
+}
+function compileSingleModule(ast, namespace, objective, moduleName, filePath) {
+    const warnings = [];
+    try {
+        const hirRaw = (0, lower_1.lowerToHIR)(ast);
+        const hir = (0, monomorphize_1.monomorphize)(hirRaw);
+        // Extract decorator metadata
+        const tickFunctions = [];
+        const loadFunctions = [];
+        const coroutineInfos = [];
+        const scheduleFunctions = [];
+        for (const fn of hir.functions) {
+            for (const dec of fn.decorators) {
+                if (dec.name === 'tick')
+                    tickFunctions.push(fn.name);
+                if (dec.name === 'load')
+                    loadFunctions.push(fn.name);
+                if (dec.name === 'coroutine') {
+                    coroutineInfos.push({ fnName: fn.name, batch: dec.args?.batch ?? 10, onDone: dec.args?.onDone });
+                }
+                if (dec.name === 'schedule') {
+                    scheduleFunctions.push({ name: fn.name, ticks: dec.args?.ticks ?? 1 });
+                }
+            }
+        }
+        // Patch the MIR module objective (lowerToMIR computes `__${namespace}` by default)
+        const mir = (0, lower_2.lowerToMIR)(hir, filePath);
+        mir.objective = objective;
+        const mirOpt = (0, pipeline_1.optimizeModule)(mir);
+        const coroResult = (0, coroutine_1.coroutineTransform)(mirOpt, coroutineInfos);
+        const mirFinal = coroResult.module;
+        tickFunctions.push(...coroResult.generatedTickFunctions);
+        const lir = (0, lower_3.lowerToLIR)(mirFinal);
+        lir.objective = objective;
+        const lirOpt = (0, pipeline_2.lirOptimizeModule)(lir);
+        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions });
+        // For named modules: rename the load.mcfunction to avoid path collision.
+        // Rename `data/${ns}/function/load.mcfunction` → `data/${ns}/function/${modName}/_load.mcfunction`
+        // and update the load tag reference accordingly.
+        if (moduleName) {
+            const loadPath = `data/${namespace}/function/load.mcfunction`;
+            const newLoadPath = `data/${namespace}/function/${moduleName}/_load.mcfunction`;
+            const loadTagPath = 'data/minecraft/tags/function/load.json';
+            for (const file of files) {
+                if (file.path === loadPath) {
+                    file.path = newLoadPath;
+                }
+                else if (file.path === loadTagPath) {
+                    const tag = JSON.parse(file.content);
+                    tag.values = tag.values.map(v => v === `${namespace}:load` ? `${namespace}:${moduleName}/_load` : v);
+                    file.content = JSON.stringify(tag, null, 2) + '\n';
+                }
+            }
+        }
+        return { files, warnings };
+    }
+    catch (err) {
+        if (err instanceof diagnostics_1.DiagnosticError)
+            throw err;
+        throw err;
+    }
+}
+/** Merge a tag file (load.json / tick.json) values into existing files array. */
+function mergeTagFile(files, newFile) {
+    const existing = files.find(f => f.path === newFile.path);
+    if (!existing) {
+        files.push(newFile);
+        return;
+    }
+    const existingJson = JSON.parse(existing.content);
+    const newJson = JSON.parse(newFile.content);
+    existingJson.values.push(...newJson.values);
+    existing.content = JSON.stringify(existingJson, null, 2) + '\n';
+}
+/** Detect circular imports using DFS. Throws if a cycle is found. */
+function detectCircularImports(parsedModules) {
+    const visited = new Set();
+    const inStack = new Set();
+    function dfs(modName, stack) {
+        if (inStack.has(modName)) {
+            const cycle = [...stack.slice(stack.indexOf(modName)), modName];
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Circular import detected: ${cycle.join(' → ')}`, { line: 1, col: 1 });
+        }
+        if (visited.has(modName))
+            return;
+        visited.add(modName);
+        inStack.add(modName);
+        const ast = parsedModules.get(modName);
+        if (ast) {
+            for (const imp of ast.imports) {
+                dfs(imp.moduleName, [...stack, modName]);
+            }
+        }
+        inStack.delete(modName);
+    }
+    for (const modName of parsedModules.keys()) {
+        dfs(modName, []);
+    }
+}
+// ---------------------------------------------------------------------------
+// AST rewriting: remap imported symbol calls to qualified names
+// ---------------------------------------------------------------------------
+/** Rewrite call expressions in the program AST.
+ *  symbolMap: localName → qualifiedName (e.g. "sin" → "math/sin") */
+function rewriteCallsInProgram(program, symbolMap) {
+    for (const fn of program.declarations) {
+        rewriteBlock(fn.body, symbolMap);
+    }
+    for (const ib of program.implBlocks) {
+        for (const m of ib.methods) {
+            rewriteBlock(m.body, symbolMap);
+        }
+    }
+}
+function rewriteBlock(block, symbolMap) {
+    for (const stmt of block) {
+        rewriteStmt(stmt, symbolMap);
+    }
+}
+function rewriteStmt(stmt, symbolMap) {
+    switch (stmt.kind) {
+        case 'let':
+        case 'expr':
+            rewriteExpr(stmt.kind === 'let' ? stmt.init : stmt.expr, symbolMap);
+            break;
+        case 'return':
+            if (stmt.value)
+                rewriteExpr(stmt.value, symbolMap);
+            break;
+        case 'if':
+            rewriteExpr(stmt.cond, symbolMap);
+            rewriteBlock(stmt.then, symbolMap);
+            if (stmt.else_)
+                rewriteBlock(stmt.else_, symbolMap);
+            break;
+        case 'while':
+            rewriteExpr(stmt.cond, symbolMap);
+            rewriteBlock(stmt.body, symbolMap);
+            break;
+        case 'for':
+            if (stmt.init)
+                rewriteStmt(stmt.init, symbolMap);
+            rewriteExpr(stmt.cond, symbolMap);
+            rewriteExpr(stmt.step, symbolMap);
+            rewriteBlock(stmt.body, symbolMap);
+            break;
+        case 'for_range':
+            rewriteExpr(stmt.start, symbolMap);
+            rewriteExpr(stmt.end, symbolMap);
+            rewriteBlock(stmt.body, symbolMap);
+            break;
+        case 'foreach':
+            rewriteExpr(stmt.iterable, symbolMap);
+            rewriteBlock(stmt.body, symbolMap);
+            break;
+        case 'match':
+            rewriteExpr(stmt.expr, symbolMap);
+            for (const arm of stmt.arms) {
+                if (arm.pattern)
+                    rewriteExpr(arm.pattern, symbolMap);
+                rewriteBlock(arm.body, symbolMap);
+            }
+            break;
+        case 'as_block':
+        case 'at_block':
+            rewriteBlock(stmt.body, symbolMap);
+            break;
+        case 'as_at':
+            rewriteBlock(stmt.body, symbolMap);
+            break;
+        case 'execute':
+            rewriteBlock(stmt.body, symbolMap);
+            break;
+        case 'let_destruct':
+            rewriteExpr(stmt.init, symbolMap);
+            break;
+        // break, continue, raw: nothing to rewrite
+    }
+}
+function rewriteExpr(expr, symbolMap) {
+    switch (expr.kind) {
+        case 'call': {
+            // Remap the function name if it's an imported symbol
+            const remapped = symbolMap.get(expr.fn);
+            if (remapped) {
+                ;
+                expr.fn = remapped;
+            }
+            for (const arg of expr.args)
+                rewriteExpr(arg, symbolMap);
+            break;
+        }
+        case 'assign':
+            rewriteExpr(expr.value, symbolMap);
+            break;
+        case 'binary':
+            rewriteExpr(expr.left, symbolMap);
+            rewriteExpr(expr.right, symbolMap);
+            break;
+        case 'unary':
+            rewriteExpr(expr.operand, symbolMap);
+            break;
+        case 'member':
+            rewriteExpr(expr.obj, symbolMap);
+            break;
+        case 'member_assign':
+            rewriteExpr(expr.obj, symbolMap);
+            rewriteExpr(expr.value, symbolMap);
+            break;
+        case 'index':
+            rewriteExpr(expr.obj, symbolMap);
+            rewriteExpr(expr.index, symbolMap);
+            break;
+        case 'array_lit':
+            for (const el of expr.elements)
+                rewriteExpr(el, symbolMap);
+            break;
+        case 'struct_lit':
+            for (const f of expr.fields)
+                rewriteExpr(f.value, symbolMap);
+            break;
+        case 'invoke':
+            rewriteExpr(expr.callee, symbolMap);
+            for (const arg of expr.args)
+                rewriteExpr(arg, symbolMap);
+            break;
+        case 'tuple_lit':
+            for (const el of expr.elements)
+                rewriteExpr(el, symbolMap);
+            break;
+        case 'static_call':
+            for (const arg of expr.args)
+                rewriteExpr(arg, symbolMap);
+            break;
+        // Literals, ident, selector, path_expr, f_string, etc: nothing to rewrite
+    }
+}
+//# sourceMappingURL=modules.js.map