Compiler: Fix register exhaustion by freeing argument registers after calls

Function calls and constructor invocations were reserving registers for
arguments via reserve_registers() but never freeing them afterwards. This
caused register count to grow unboundedly with each call, eventually
hitting the 255 register limit in code with many function calls.

Added free_registers() method to BytecodeBuilder and updated emit_call(),
compile_new_expression(), and SuperCall handling to free argument registers
after the call completes.

- Add BytecodeBuilder::free_registers(start, count) to free consecutive registers
- Free argument registers after Call/CallSpread opcodes in emit_call()
- Free argument registers after Construct/ConstructSpread in compile_new_expression()
- Free argument registers after SuperCall

This fixes the "Too many registers needed (max 255)" error when running
examples/collections/main.ts which has ~70 function calls.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: DmitryBochkarev

src/compiler/builder.rs

@@ -562,6 +562,14 @@ impl BytecodeBuilder {
     pub fn reserve_registers(&mut self, count: u8) -> Result<Register, JsError> {
         self.registers.reserve_range(count)
     }
+
+    /// Free a range of consecutive registers (frees from end to start for optimal reuse)
+    pub fn free_registers(&mut self, start: Register, count: u8) {
+        // Free in reverse order so the allocator can reclaim them contiguously
+        for i in (0..count).rev() {
+            self.registers.free(start + i);
+        }
+    }
 }
 
 impl Default for BytecodeBuilder {

src/compiler/compile_expr.rs

@@ -1713,13 +1713,20 @@ impl Compiler {
         // Handle super() call
         if matches!(call.callee.as_ref(), Expression::Super(_)) {
             // Compile arguments (spread not supported for super calls yet)
-            let (args_start, argc, _has_spread) = self.compile_arguments(&call.arguments)?;
+            let (args_start, argc, has_spread) = self.compile_arguments(&call.arguments)?;
 
             self.builder.emit(Op::SuperCall {
                 dst,
                 args_start,
                 argc,
             });
+
+            // Free argument registers
+            if has_spread {
+                self.builder.free_register(args_start);
+            } else if argc > 0 {
+                self.builder.free_registers(args_start, argc);
+            }
             return Ok(());
         }
 
@@ -2159,6 +2166,8 @@ impl Compiler {
                 args_start,
                 argc,
             });
+            // For spread calls, args_start is a single array register
+            self.builder.free_register(args_start);
         } else {
             self.builder.emit(Op::Call {
                 dst,
@@ -2167,6 +2176,10 @@ impl Compiler {
                 args_start,
                 argc,
             });
+            // Free the argument registers after the call
+            if argc > 0 {
+                self.builder.free_registers(args_start, argc);
+            }
         }
     }
 
@@ -2220,13 +2233,19 @@ impl Compiler {
                 args_start,
                 argc,
             });
+            // For spread, args_start is a single array register
+            self.builder.free_register(args_start);
         } else {
             self.builder.emit(Op::Construct {
                 dst,
                 callee: callee_reg,
                 args_start,
                 argc,
             });
+            // Free the argument registers after the construct
+            if argc > 0 {
+                self.builder.free_registers(args_start, argc);
+            }
         }
 
         self.builder.free_register(callee_reg);

tests/compiler.rs

@@ -705,3 +705,84 @@ fn test_register_usage_many_variables() {
         }
     }
 }
+
+#[test]
+fn test_register_usage_many_functions() {
+    // Many function declarations at module level
+    let mut code = String::new();
+    for i in 0..50 {
+        code.push_str(&format!(
+            "function func{}(x: number): number {{ return x + {}; }}\n",
+            i, i
+        ));
+    }
+    code.push_str("func49(1)");
+
+    let result = std::panic::catch_unwind(|| compile(&code));
+    match result {
+        Ok(chunk) => {
+            println!("50 functions register count: {}", chunk.register_count);
+            assert!(
+                chunk.register_count < 100,
+                "Register count {} too high for 50 function declarations",
+                chunk.register_count
+            );
+        }
+        Err(e) => {
+            panic!("Compilation failed with 50 functions: {:?}", e);
+        }
+    }
+}
+
+#[test]
+fn test_register_usage_graph_like_module() {
+    // Simulate the graph.ts pattern - many exported functions
+    let chunk = compile(
+        r#"
+        function createGraph() { return { nodes: new Map() }; }
+        function addNode(graph, node) { if (!graph.nodes.has(node)) { graph.nodes.set(node, new Set()); } }
+        function addEdge(graph, from, to) { addNode(graph, from); addNode(graph, to); graph.nodes.get(from).add(to); }
+        function hasEdge(graph, from, to) { const n = graph.nodes.get(from); return n !== undefined && n.has(to); }
+        function getNeighbors(graph, node) { return graph.nodes.get(node) || new Set(); }
+        function removeEdge(graph, from, to) { const n = graph.nodes.get(from); if (n) { n.delete(to); } }
+        function bfs(graph, start) {
+            const visited = new Set();
+            const result = [];
+            const queue = [start];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (visited.has(current)) continue;
+                visited.add(current);
+                result.push(current);
+                const neighbors = getNeighbors(graph, current);
+                for (const neighbor of neighbors) {
+                    if (!visited.has(neighbor)) queue.push(neighbor);
+                }
+            }
+            return result;
+        }
+        function dfs(graph, start) {
+            const visited = new Set();
+            const result = [];
+            function visit(node) {
+                if (visited.has(node)) return;
+                visited.add(node);
+                result.push(node);
+                for (const neighbor of getNeighbors(graph, node)) visit(neighbor);
+            }
+            visit(start);
+            return result;
+        }
+        const g = createGraph();
+        addEdge(g, "A", "B");
+        bfs(g, "A");
+    "#,
+    );
+
+    println!("Graph-like module register count: {}", chunk.register_count);
+    assert!(
+        chunk.register_count < 150,
+        "Register count {} too high for graph-like module",
+        chunk.register_count
+    );
+}