feat: start thinking about MIR analysis passes

.gitignore

···
 *.c
 *.ll
 *.s
+*.bc
+*.dot
+*.png

Cargo.lock

···
 version = "0.1.0"
 
 [[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
 name = "cc"
 version = "1.2.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "find-msvc-tools",
  "shlex",
 ]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "clap"
···
  "heck",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.111",
 ]
 
 [[package]]
···
 checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
 [[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "dot-generator"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0aaac7ada45f71873ebce336491d1c1bc4a7c8042c7cea978168ad59e805b871"
+dependencies = [
+ "dot-structures",
+]
+
+[[package]]
+name = "dot-structures"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "498cfcded997a93eb31edd639361fa33fd229a8784e953b37d71035fe3890b7b"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
 name = "find-msvc-tools"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 [[package]]
 name = "frontend"
 version = "0.1.0"
+dependencies = [
+ "graphviz-rust",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "graphviz-rust"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db134cb611668917cabf340af9a39518426f9a10827b4cedcb4cdcf84443f6d0"
+dependencies = [
+ "dot-generator",
+ "dot-structures",
+ "into-attr",
+ "into-attr-derive",
+ "pest",
+ "pest_derive",
+ "rand",
+ "tempfile",
+]
 
 [[package]]
 name = "heck"
···
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "into-attr"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18b48c537e49a709e678caec3753a7dba6854661a1eaa27675024283b3f8b376"
+dependencies = [
+ "dot-structures",
+]
+
+[[package]]
+name = "into-attr-derive"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecac7c1ae6cd2c6a3a64d1061a8bdc7f52ff62c26a831a2301e54c1b5d70d5b1"
+dependencies = [
+ "dot-generator",
+ "dot-structures",
+ "into-attr",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
···
 version = "0.2.178"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
 [[package]]
 name = "llvm-sys"
···
 ]
 
 [[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
 name = "once_cell"
 version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
+name = "pest"
+version = "2.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbcfd20a6d4eeba40179f05735784ad32bdaef05ce8e8af05f180d45bb3e7e22"
+dependencies = [
+ "memchr",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51f72981ade67b1ca6adc26ec221be9f463f2b5839c7508998daa17c23d94d7f"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dee9efd8cdb50d719a80088b76f81aec7c41ed6d522ee750178f83883d271625"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf1d70880e76bdc13ba52eafa6239ce793d85c8e43896507e43dd8984ff05b82"
+dependencies = [
+ "pest",
+ "sha2",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
 name = "proc-macro2"
 version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
 name = "regex-lite"
 version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
 
 [[package]]
+name = "rustix"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
 name = "semver"
 version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
 
 [[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
 name = "shlex"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
 version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
···
 ]
 
 [[package]]
+name = "tempfile"
+version = "3.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
+dependencies = [
+ "fastrand",
+ "getrandom",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
 name = "thiserror"
 version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.111",
 ]
 
 [[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+
+[[package]]
 name = "unicode-ident"
 version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "windows-link",
 ]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]

cli/src/main.rs

···
 use clap::Parser;
 use codegen::{CodegenBackend, codegen};
 use frontend::do_frontend;
-use frontend::visualize::MIRVisualizer;
 
 #[derive(Parser, Debug)]
 #[command(author, version)]
···
     backend: CodegenBackend,
     #[arg(short, long)]
     verbose: bool,
+    #[arg(short, long)]
+    mir: bool
 }
 
 fn main() {
     let options = Options::parse();
-    let (module, ctx) = match do_frontend(&options.file) {
+    let (module, ctx) = match do_frontend(&options.file, options.mir) {
         Ok(result) => result,
         Err(e) => {
             eprintln!("{}", e);
             std::process::exit(1);
         }
     };
-
-    if options.verbose {
-        module.visualize(0);
-    }
 
     codegen(CodegenBackend::LLVM, module, ctx, options.verbose).unwrap();
 }

frontend/Cargo.toml

···
 edition = "2024"
 
 [dependencies]
+graphviz-rust = "0.9.6"

frontend/src/lib.rs

···
 mod typecheck;
 
 pub use ctx::{Ctx, Symbol};
-pub use mir::{Function, visualize};
-pub use span::{Diagnostic, DUMMY_SPAN, SourceMap, Span, SpanExt, Spanned};
 pub use lex::BinOp;
+pub use mir::{Function, visualize};
+pub use span::{Diagnostic, SourceMap, Span, SpanExt, Spanned};
 
 use ast_visitor::{AstToMIR, AstVisitor};
 use std::collections::VecDeque;
 use std::fs::File;
 use std::io::Read;
 
-pub fn do_frontend(file: &str) -> Result<(mir::Module, Ctx), String> {
+pub fn do_frontend(file: &str, output_mir: bool) -> Result<(mir::Module, Ctx), String> {
     let mut file = File::open(file).map_err(|e| format!("failed to open file: {}", e))?;
 
     let mut contents = String::new();
-    file.read_to_string(&mut contents).map_err(|e| format!("failed to read file: {}", e))?;
+    file.read_to_string(&mut contents)
+        .map_err(|e| format!("failed to read file: {}", e))?;
     contents = contents.trim().to_string();
 
     let source_map = SourceMap::new(contents.clone());
···
     let mut ast_visitor = AstToMIR::new(&ctx);
     ast_visitor.visit_module(module);
 
-    Ok((ast_visitor.produce_module(), ctx))
+    let module = mir::run_passes(ast_visitor.produce_module(), output_mir);
+    Ok((module, ctx))
 }

frontend/src/mir/domtree.rs

···
+use std::collections::HashMap;
+
+pub trait Searchable<V: Clone> {
+    type NodeId: Clone + Eq + std::hash::Hash;
+
+    /// Required methods:
+    /// Depth-first search traversal of the graph starting from the given node, applying the visit
+    /// function to each node
+    fn dfs<F>(&self, start: Self::NodeId, visit: &mut F)
+    where
+        F: FnMut(Self::NodeId);
+
+    /// Returns the nodes in the graph, order is not guaranteed
+    fn nodes(&self) -> Vec<Self::NodeId>;
+
+    /// Derived method:
+    /// Collects the nodes in post order starting from the given node
+    fn post_order_collect(&self, start: Self::NodeId) -> Vec<Self::NodeId> {
+        let mut visited = Vec::new();
+        self.dfs(start, &mut |id| {
+            visited.push(id.clone());
+        });
+        visited
+    }
+}
+
+pub trait DomTree<V>: Searchable<V>
+where
+    V: Clone + Eq + std::hash::Hash,
+{
+    /// Required methods:
+    ///
+    /// Returns the dominator of a node in the dominator tree
+    fn dom(&self, start: Self::NodeId) -> Option<Self::NodeId>;
+    /// Sets the dominator of a node in the dominator tree
+    fn set_dom(&mut self, node: Self::NodeId, dom: Option<Self::NodeId>);
+    /// Clears the dominator tree, which is a precondition for computing the dominator tree
+    fn reset_dom(&mut self);
+    /// Returns the predecessors of a node in the dominator tree
+    fn preds(&self, node: Self::NodeId) -> Vec<Self::NodeId>;
+
+    /// Derived methods:
+    /// Helper method to compute the dominance intersection of two nodes
+    fn intersect(
+        &self,
+        order_map: &HashMap<Self::NodeId, usize>,
+        mut node1: Self::NodeId,
+        mut node2: Self::NodeId,
+    ) -> Self::NodeId {
+        while node1 != node2 {
+            if order_map[&node1] > order_map[&node2] {
+                node1 = self
+                    .dom(node1.clone())
+                    .expect("Every node must eventually have a dominator");
+            } else {
+                node2 = self
+                    .dom(node2.clone())
+                    .expect("Every node must eventually have a dominator");
+            }
+        }
+        node1
+    }
+
+    /// Computes the dominator tree starting from the given node
+    /// https://en.wikipedia.org/wiki/Dominator_(graph_theory)#Algorithms
+    fn compute_dom_tree(&mut self, start: Self::NodeId) {
+        self.reset_dom();
+        self.set_dom(start.clone(), Some(start.clone()));
+
+        let mut order: Vec<Self::NodeId> = self.post_order_collect(start);
+        order.reverse();
+
+        let order_map: HashMap<Self::NodeId, usize> = order
+            .iter()
+            .enumerate()
+            .map(|(i, id)| (id.clone(), i))
+            .collect();
+
+        let mut changed = true;
+        while changed {
+            changed = false;
+
+            // for each n in N - {n0}:
+            for node in order.iter().skip(1) {
+                let preds = &self.preds(node.clone());
+
+                let mut new_dominator_opt = None;
+                for pred in preds {
+                    if self.dom(pred.clone()).is_some() {
+                        new_dominator_opt = Some(pred.clone());
+                        break;
+                    }
+                }
+                let mut new_dominator = match new_dominator_opt {
+                    Some(n) => n,
+                    None => continue, // if no predecessor has a computed dominator, skip
+                };
+
+                for pred in preds {
+                    if self.dom(pred.clone()).is_some() {
+                        new_dominator = self.intersect(&order_map, new_dominator, pred.clone());
+                    }
+                }
+
+                if self.dom(node.clone()) != Some(new_dominator.clone()) {
+                    self.set_dom(node.clone(), Some(new_dominator));
+                    changed = true;
+                }
+            }
+        }
+    }
+
+    /// Returns the dominator tree as a HashMap
+    fn dom_tree(&self) -> HashMap<Self::NodeId, Self::NodeId> {
+        let mut dom_tree = HashMap::new();
+        for node in self.nodes() {
+            if let Some(dom) = self.dom(node.clone()) {
+                dom_tree.insert(node.clone(), dom);
+            }
+        }
+        dom_tree
+    }
+}

frontend/src/mir/graph.rs

···
+use std::collections::{HashMap, HashSet};
+
+use graphviz_rust::{
+    dot_generator::*,
+    dot_structures::*,
+    printer::{DotPrinter, PrinterContext},
+};
+
+use super::visit::visit_block_succs;
+use crate::mir::{
+    domtree::{DomTree, Searchable},
+    *,
+};
+
+#[derive(Debug, Default)]
+pub struct FlowNode {
+    predecessors: HashSet<BlockId>,
+    successors: HashSet<BlockId>,
+}
+
+pub struct FlowGraph {
+    blocks: HashMap<BlockId, FlowNode>,
+    entry: Option<BlockId>,
+    dominators: HashMap<BlockId, Option<BlockId>>,
+}
+
+impl FlowGraph {
+    pub fn new() -> Self {
+        Self {
+            blocks: HashMap::new(),
+            entry: None,
+            dominators: HashMap::new(),
+        }
+    }
+
+    pub fn compute(&mut self, func: &Function) {
+        self.blocks.clear();
+        self.entry = None;
+
+        if !func.blocks.is_empty() {
+            self.entry = Some(func.blocks[0].block_id);
+        }
+
+        for block in func.blocks.iter() {
+            self.blocks.entry(block.block_id).or_default();
+        }
+
+        for block in func.blocks.iter() {
+            visit_block_succs(func, block, |to| {
+                self.add_edge(block.block_id, to);
+            });
+        }
+
+        if let Some(first_block) = func.blocks.first() {
+            self.entry = Some(first_block.block_id);
+        }
+    }
+
+    fn add_edge(&mut self, from: BlockId, to: BlockId) {
+        self.blocks.entry(from).or_default().successors.insert(to);
+        self.blocks.entry(to).or_default().predecessors.insert(from);
+    }
+}
+
+impl Searchable<BlockId> for FlowGraph {
+    type NodeId = BlockId;
+
+    fn dfs<F>(&self, start: Self::NodeId, visit: &mut F)
+    where
+        F: FnMut(Self::NodeId),
+    {
+        let mut visited = HashSet::new();
+        let mut stack = vec![start];
+
+        while let Some(node) = stack.pop() {
+            if !visited.contains(&node) {
+                visited.insert(node);
+                visit(node);
+                stack.extend(self.blocks[&node].successors.iter());
+            }
+        }
+    }
+
+    fn nodes(&self) -> Vec<Self::NodeId> {
+        self.blocks.keys().cloned().collect()
+    }
+}
+
+impl DomTree<BlockId> for FlowGraph {
+    fn dom(&self, start: Self::NodeId) -> Option<Self::NodeId> {
+        self.dominators.get(&start).unwrap_or(&None).clone()
+    }
+
+    fn set_dom(&mut self, node: Self::NodeId, dom: Option<Self::NodeId>) {
+        self.dominators.insert(node, dom);
+    }
+
+    fn reset_dom(&mut self) {
+        self.dominators.iter_mut().for_each(|(_, dom)| *dom = None);
+    }
+
+    fn preds(&self, node: Self::NodeId) -> Vec<Self::NodeId> {
+        self.blocks
+            .get(&node)
+            .unwrap()
+            .predecessors
+            .iter()
+            .copied()
+            .collect()
+    }
+}
+
+// Graphviz functions
+impl FlowGraph {
+    pub fn to_dot(&self) -> Graph {
+        let mut stmts: Vec<Stmt> = vec![
+            stmt!(attr!("rankdir", "TB")),
+            stmt!(attr!("fontname", esc "Helvetica")),
+        ];
+
+        if let Some(entry) = self.entry {
+            stmts.push(stmt!(
+                node!(esc format!("bb{}", entry); attr!("style", "filled"), attr!("fillcolor", "lightgreen"))
+            ));
+        }
+
+        for block_id in self.blocks.keys() {
+            let label = format!("BB{}", block_id);
+            stmts.push(stmt!(
+                node!(esc format!("bb{}", block_id); attr!("label", esc label))
+            ));
+        }
+
+        for (from, flow_node) in &self.blocks {
+            for to in &flow_node.successors {
+                stmts.push(stmt!(
+                    edge!(node_id!(esc format!("bb{}", from)) => node_id!(esc format!("bb{}", to)))
+                ));
+            }
+        }
+
+        graph!(strict di id!("FlowGraph"), stmts)
+    }
+
+    pub fn to_dot_string(&self) -> String {
+        self.to_dot().print(&mut PrinterContext::default())
+    }
+}

frontend/src/mir/ir.rs

···
+use std::fmt::Display;
+
+use crate::lex::BinOp;
+
+// corresponds to locals in the defining function
+pub type LocalId = usize;
+pub type BlockId = usize;
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum Ty {
+    Bool,
+    Char,
+    Int,
+    Unit,
+    Array(Box<Ty>, usize),
+    DynArray(Box<Ty>),
+    Tuple(Vec<Ty>),
+    Ptr(Box<Ty>),
+    TaggedUnion(Vec<(u8, Ty)>),
+    Record(Vec<Ty>),
+}
+
+impl Ty {
+    pub fn bytes(&self) -> usize {
+        match self {
+            Ty::Bool => 1,
+            Ty::Char => 1,
+            Ty::Int => 4,
+            Ty::Unit => 0,
+            Ty::Array(ty, len) => ty.bytes() * *len,
+            Ty::DynArray(ty) => ty.bytes(),
+            Ty::Tuple(tys) => tys.iter().map(|t| t.bytes()).sum(),
+            Ty::Ptr(_) => 4,
+            // this just returns the size of the largest field, not including the tag byte
+            Ty::TaggedUnion(tags_tys) => tags_tys.iter().map(|(tag, ty)| ty.bytes()).max().unwrap(),
+            Ty::Record(tys) => tys.iter().map(|t| t.bytes()).sum(),
+        }
+    }
+}
+
+impl Display for Ty {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Ty::Bool => write!(f, "bool"),
+            Ty::Char => write!(f, "char"),
+            Ty::Int => write!(f, "int"),
+            Ty::Unit => write!(f, "unit"),
+            Ty::Array(ty, len) => write!(f, "[{}]{{ {} }}", ty, len),
+            Ty::DynArray(ty) => write!(f, "dyn{{ {} }}", ty),
+            Ty::Tuple(tys) => write!(
+                f,
+                "({})",
+                tys.iter()
+                    .map(|t| t.to_string())
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
+            Ty::Ptr(ty) => write!(f, "^{}", ty),
+            Ty::TaggedUnion(tags_tys) => {
+                let tags_tys_str = tags_tys
+                    .iter()
+                    .map(|(tag, ty)| format!("{}:<{}>", tag, ty))
+                    .collect::<Vec<String>>()
+                    .join("|");
+
+                write!(f, "{}", tags_tys_str)
+            }
+
+            Ty::Record(tys) => write!(
+                f,
+                "{{ {} }}",
+                tys.iter()
+                    .map(|t| t.to_string())
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum PlaceKind {
+    /// array index operations
+    Index(LocalId),
+    /// field idx, and a type for validation
+    Field(usize, Ty),
+    Deref,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+// places are memory locations
+pub struct Place {
+    pub local: LocalId,
+    // we use the place kind to determine where we are looking in the local
+    // for example, if we are looking at a field, we need to know the field index
+    // if we are looking at an array index, we need to know the array index
+    pub kind: PlaceKind,
+}
+
+impl Place {
+    pub fn new(local: LocalId, kind: PlaceKind) -> Self {
+        Self { local, kind }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Operand {
+    Constant(i32),
+    Copy(Place),
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum AllocKind {
+    Array(Ty),
+    DynArray(Ty),
+    Tuple(Vec<Ty>),
+    Record(Vec<Ty>),
+    Variant(u8, Ty),
+}
+
+impl Display for AllocKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AllocKind::Array(ty) => write!(f, "array<{}>", ty),
+            AllocKind::Tuple(tys) => {
+                let ty_str = tys
+                    .iter()
+                    .map(|t| t.to_string())
+                    .collect::<Vec<String>>()
+                    .join(" * ");
+
+                write!(f, "{}", ty_str)
+            }
+            AllocKind::DynArray(ty) => write!(f, "dyn_array<{}>", ty),
+            AllocKind::Record(tys) => {
+                let ty_str = tys
+                    .iter()
+                    .map(|t| t.to_string())
+                    .collect::<Vec<String>>()
+                    .join(",");
+
+                write!(f, "{{{}}}", ty_str)
+            }
+            AllocKind::Variant(tag, ty) => write!(f, "Variant({})<{}>", tag, ty),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum RValue {
+    Use(Operand),
+    BinOp(BinOp, Operand, Operand),
+    Alloc(AllocKind, Vec<Operand>),
+}
+
+impl RValue {
+    pub fn place(&self) -> Option<Place> {
+        match self {
+            RValue::Use(op) => match op {
+                Operand::Constant(_) => None,
+                Operand::Copy(p) => Some(p.clone()),
+            },
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Statement {
+    // This is in SSA form, so assigning defines a new local
+    Assign(LocalId, RValue),
+    Phi(LocalId, Vec<LocalId>),
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Terminator {
+    Return,
+    Br(BlockId),
+    // usize is index of the local for the condition
+    BrIf(usize, BlockId, BlockId),
+    Call {
+        function_name: String,
+        args: Vec<RValue>,
+        destination: Option<LocalId>,
+        target: BlockId,
+    },
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct BasicBlock {
+    pub block_id: BlockId,
+    pub stmts: Vec<Statement>,
+    // TODO: should this possibly be an optional at some points
+    pub terminator: Terminator,
+}
+
+impl BasicBlock {
+    pub fn new(block_id: BlockId) -> Self {
+        Self {
+            block_id,
+            stmts: Vec::new(),
+            terminator: Terminator::Return,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Local {
+    pub id: LocalId,
+    pub ty: Ty,
+}
+
+impl Local {
+    pub fn new(local_id: LocalId, ty: Ty) -> Self {
+        Self { id: local_id, ty }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Function {
+    pub name: String,
+    pub blocks: Vec<BasicBlock>,
+    pub parameters: usize,
+    pub return_ty: Ty,
+    pub locals: Vec<Local>,
+}
+
+impl IntoIterator for Function {
+    type Item = BasicBlock;
+    type IntoIter = std::vec::IntoIter<BasicBlock>;
+
+    // TOOD: make this a proper CFG traversal
+    fn into_iter(self) -> Self::IntoIter {
+        self.blocks.into_iter()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Extern {
+    pub name: String,
+    pub params: Vec<Ty>,
+    pub return_ty: Ty,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Module {
+    pub functions: Vec<Function>,
+    pub constants: Vec<RValue>,
+    pub externs: Vec<Extern>,
+}

frontend/src/mir/mod.rs

···
-#![allow(unused)]
-
-pub mod visualize;
 mod graph;
+pub mod ir;
 mod visit;
-
-use std::fmt::Display;
-
-use crate::lex::BinOp;
-
-// corresponds to locals in the defining function
-pub type LocalId = usize;
-pub type BlockId = usize;
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum Ty {
-    Bool,
-    Char,
-    Int,
-    Unit,
-    Array(Box<Ty>, usize),
-    DynArray(Box<Ty>),
-    Tuple(Vec<Ty>),
-    Ptr(Box<Ty>),
-    TaggedUnion(Vec<(u8, Ty)>),
-    Record(Vec<Ty>),
-}
-
-impl Ty {
-    pub fn bytes(&self) -> usize {
-        match self {
-            Ty::Bool => 1,
-            Ty::Char => 1,
-            Ty::Int => 4,
-            Ty::Unit => 0,
-            Ty::Array(ty, len) => ty.bytes() * *len,
-            Ty::DynArray(ty) => ty.bytes(),
-            Ty::Tuple(tys) => tys.iter().map(|t| t.bytes()).sum(),
-            Ty::Ptr(_) => 4,
-            // this just returns the size of the largest field, not including the tag byte
-            Ty::TaggedUnion(tags_tys) => tags_tys.iter().map(|(tag, ty)| ty.bytes()).max().unwrap(),
-            Ty::Record(tys) => tys.iter().map(|t| t.bytes()).sum(),
-        }
-    }
-}
-
-impl Display for Ty {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Ty::Bool => write!(f, "bool"),
-            Ty::Char => write!(f, "char"),
-            Ty::Int => write!(f, "int"),
-            Ty::Unit => write!(f, "unit"),
-            Ty::Array(ty, len) => write!(f, "[{}]{{ {} }}", ty, len),
-            Ty::DynArray(ty) => write!(f, "dyn{{ {} }}", ty),
-            Ty::Tuple(tys) => write!(
-                f,
-                "({})",
-                tys.iter()
-                    .map(|t| t.to_string())
-                    .collect::<Vec<String>>()
-                    .join(", ")
-            ),
-            Ty::Ptr(ty) => write!(f, "^{}", ty),
-            Ty::TaggedUnion(tags_tys) => {
-                let tags_tys_str = tags_tys
-                    .iter()
-                    .map(|(tag, ty)| format!("{}:<{}>", tag, ty))
-                    .collect::<Vec<String>>()
-                    .join("|");
-
-                write!(f, "{}", tags_tys_str)
-            }
-
-            Ty::Record(tys) => write!(
-                f,
-                "{{ {} }}",
-                tys.iter()
-                    .map(|t| t.to_string())
-                    .collect::<Vec<String>>()
-                    .join(", ")
-            ),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum PlaceKind {
-    /// array index operations
-    Index(LocalId),
-    /// field idx, and a type for validation
-    Field(usize, Ty),
-    Deref,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-// places are memory locations
-pub struct Place {
-    pub local: LocalId,
-    // we use the place kind to determine where we are looking in the local
-    // for example, if we are looking at a field, we need to know the field index
-    // if we are looking at an array index, we need to know the array index
-    pub kind: PlaceKind,
-}
-
-impl Place {
-    pub fn new(local: LocalId, kind: PlaceKind) -> Self {
-        Self { local, kind }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum Operand {
-    Constant(i32),
-    Copy(Place),
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum AllocKind {
-    Array(Ty),
-    DynArray(Ty),
-    Tuple(Vec<Ty>),
-    Record(Vec<Ty>),
-    Variant(u8, Ty),
-}
-
-impl Display for AllocKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            AllocKind::Array(ty) => write!(f, "array<{}>", ty),
-            AllocKind::Tuple(tys) => {
-                let ty_str = tys
-                    .iter()
-                    .map(|t| t.to_string())
-                    .collect::<Vec<String>>()
-                    .join(" * ");
+pub mod visualize;
+mod domtree;
 
-                write!(f, "{}", ty_str)
-            }
-            AllocKind::DynArray(ty) => write!(f, "dyn_array<{}>", ty),
-            AllocKind::Record(tys) => {
-                let ty_str = tys
-                    .iter()
-                    .map(|t| t.to_string())
-                    .collect::<Vec<String>>()
-                    .join(",");
+pub use ir::*;
 
-                write!(f, "{{{}}}", ty_str)
-            }
-            AllocKind::Variant(tag, ty) => write!(f, "Variant({})<{}>", tag, ty),
-        }
-    }
-}
+#[allow(unused)]
+trait MirPass {}
 
-#[derive(Debug, PartialEq, Eq)]
-pub enum RValue {
-    Use(Operand),
-    BinOp(BinOp, Operand, Operand),
-    Alloc(AllocKind, Vec<Operand>),
-}
+pub fn run_passes(module: Module, output_mir: bool) -> Module {
+    let mut cfg = graph::FlowGraph::new();
 
-impl RValue {
-    pub fn place(&self) -> Option<Place> {
-        match self {
-            RValue::Use(op) => match op {
-                Operand::Constant(_) => None,
-                Operand::Copy(p) => Some(p.clone()),
-            },
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum Statement {
-    // This is in SSA form, so assigning defines a new local
-    Assign(LocalId, RValue),
-    Phi(LocalId, Vec<LocalId>),
-}
+    for func in &module.functions {
+        cfg.compute(func);
 
-#[derive(Debug, PartialEq, Eq)]
-pub enum Terminator {
-    Return,
-    Br(BlockId),
-    // usize is index of the local for the condition
-    BrIf(usize, BlockId, BlockId),
-    Call {
-        function_name: String,
-        args: Vec<RValue>,
-        destination: Option<LocalId>,
-        target: BlockId,
-    },
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct BasicBlock {
-    pub block_id: BlockId,
-    pub stmts: Vec<Statement>,
-    // TODO: should this possibly be an optional at some points
-    pub terminator: Terminator,
-}
-
-impl BasicBlock {
-    pub fn new(block_id: BlockId) -> Self {
-        Self {
-            block_id,
-            stmts: Vec::new(),
-            terminator: Terminator::Return,
+        if output_mir {
+            println!("{}", cfg.to_dot_string());
         }
     }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct Local {
-    pub id: LocalId,
-    pub ty: Ty,
-}
-
-impl Local {
-    pub fn new(local_id: LocalId, ty: Ty) -> Self {
-        Self { id: local_id, ty }
-    }
-}
 
-#[derive(Debug, PartialEq, Eq)]
-pub struct Function {
-    pub name: String,
-    pub blocks: Vec<BasicBlock>,
-    pub parameters: usize,
-    pub return_ty: Ty,
-    pub locals: Vec<Local>,
-}
-
-impl IntoIterator for Function {
-    type Item = BasicBlock;
-    type IntoIter = std::vec::IntoIter<BasicBlock>;
-
-    // TOOD: make this a proper CFG traversal
-    fn into_iter(self) -> Self::IntoIter {
-        self.blocks.into_iter()
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct Extern {
-    pub name: String,
-    pub params: Vec<Ty>,
-    pub return_ty: Ty,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct Module {
-    pub functions: Vec<Function>,
-    pub constants: Vec<RValue>,
-    pub externs: Vec<Extern>,
+    module
 }

frontend/src/mir/visit.rs

···
+use crate::mir::*;
+
+pub fn visit_block_succs<F: FnMut(BlockId)>(_func: &Function, block: &BasicBlock, mut visit: F) {
+    match &block.terminator {
+        Terminator::Return => {}
+        Terminator::Br(block_id) => {
+            visit(*block_id);
+        }
+        Terminator::BrIf(_, then_, else_) => {
+            visit(*then_);
+            visit(*else_);
+        }
+        Terminator::Call { target, .. } => {
+            visit(*target);
+        }
+    }
+}