⚡ Bolt: O(N) block predecessor mapping optimization

compiler/ir/Cargo.toml

@@ -16,3 +16,8 @@ serde = { workspace = true }
 techscript_lexer = { path = "../lexer" }
 techscript_parser = { path = "../parser" }
 techscript_semantic = { path = "../semantic" }
+criterion = "0.5"
+
+[[bench]]
+name = "builder_bench"
+harness = false

compiler/ir/benches/builder_bench.rs

@@ -0,0 +1,38 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use techscript_ir::builder::IRBuilder;
+use techscript_ir::types::IRType;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench_function("seal_function 10000 blocks", |b| {
+        b.iter(|| {
+            let mut builder = IRBuilder::new();
+            builder.start_function("bench_func".to_string(), IRType::Void);
+
+            let num_blocks = 10000;
+            let mut blocks = vec![];
+            for i in 0..num_blocks {
+                let block_id = builder.new_block(format!("block_{}", i));
+                blocks.push(block_id);
+            }
+
+            for i in 0..(num_blocks - 1) {
+                builder.enter_block(blocks[i], format!("block_{}", i));
+                builder.emit_terminator(
+                    techscript_ir::instruction::TerminatorKind::Jump(blocks[i + 1]),
+                    techscript_common::Span { start: 0, end: 0 },
+                );
+            }
+
+            builder.enter_block(blocks[num_blocks - 1], format!("block_{}", num_blocks - 1));
+            builder.emit_terminator(
+                techscript_ir::instruction::TerminatorKind::Return(None),
+                techscript_common::Span { start: 0, end: 0 },
+            );
+
+            builder.seal_function();
+        });
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

compiler/ir/src/builder.rs

@@ -263,15 +263,15 @@ impl IRBuilder {
             }
 
             // Map predecessors
-            for i in 0..num_blocks {
-                let block_id = func.blocks[i].id;
-                let mut preds = Vec::new();
-                for other in &func.blocks {
-                    if other.successors.contains(&block_id) {
-                        preds.push(other.id);
-                    }
+            let mut pred_map = HashMap::new();
+            for block in &func.blocks {
+                for &succ in &block.successors {
+                    pred_map.entry(succ).or_insert_with(Vec::new).push(block.id);
                 }
-                func.blocks[i].predecessors = preds;
+            }
+
+            for block in &mut func.blocks {
+                block.predecessors = pred_map.remove(&block.id).unwrap_or_default();
             }
 
             self.functions.push(func);