remove old code

src/parser.rs

@@ -12,7 +12,6 @@ use crate::{
     string_table::{ImmOrIndex, Index, StringTable},
     symbol_table::{SymbolKind, SymbolTable},
     tokens::Token,
-    variant,
 };
 
 #[derive(Debug, thiserror::Error)]
@@ -2486,87 +2485,3 @@ static PRECEDENCE_MAP: std::sync::LazyLock<HashMap<Token, u32>> = std::sync::Laz
         (Token::Slash, 100),
     ])
 });
-
-#[cfg(test)]
-mod tests {
-    use crate::lexer::Tokenizer;
-
-    use super::*;
-
-    #[test]
-    fn render_ast() {
-        let src = "let a: u21 = 3u32;";
-        let tokens = Tokenizer::new(src.as_bytes()).unwrap();
-
-        let mut tree = Tree::new();
-        tree.parse(tokens.iter()).unwrap();
-
-        let mut buf = String::new();
-        tree.render(&mut buf).unwrap();
-        println!("{buf}");
-    }
-    #[test]
-    fn render_ast2() {
-        let src = "
-fn main() -> void {
-let a: u32 = 0u32;
-a == 1u32
-}
-fn square(x: u32) -> u32 {
-x * x
-}
-";
-        let tokens = Tokenizer::new(src.as_bytes()).unwrap();
-
-        let mut tree = Tree::new();
-        tree.parse(tokens.iter()).unwrap();
-
-        let mut buf = String::new();
-        tree.render(&mut buf).unwrap();
-        println!("{buf}");
-    }
-
-    #[test]
-    fn render_ast3() {
-        let src = "
-fn main() -> void {
-let a: u32 = 0u32;
-a == global
-}
-const global: u32 = 42u32;
-";
-        let tokens = Tokenizer::new(src.as_bytes()).unwrap();
-
-        let mut tree = Tree::new();
-        tree.parse(tokens.iter()).unwrap();
-
-        let mut buf = String::new();
-        tree.render(&mut buf).unwrap();
-        println!("{buf}");
-    }
-
-    #[test]
-    fn comptime() {
-        let src = "
-fn main() -> void {
-let x: u32;
-x = 666u32;
-let a = x + 3 * 49573 << 4;
-}
-";
-        let tokens = Tokenizer::new(src.as_bytes()).unwrap();
-
-        let mut tree = Tree::new();
-        tree.parse(tokens.iter()).unwrap();
-
-        let mut buf = String::new();
-        tree.render(&mut buf).unwrap();
-        println!("{buf}");
-
-        tree.fold_comptime_with_visitor(tree.global_decls.first().cloned().unwrap());
-
-        let mut buf = String::new();
-        tree.render(&mut buf).unwrap();
-        println!("{buf}");
-    }
-}

src/triples.rs

@@ -2,7 +2,7 @@
 
 use std::{
     cmp::Ordering,
-    collections::{BTreeMap, BTreeSet, HashMap, VecDeque},
+    collections::{BTreeMap, BTreeSet, HashMap},
 };
 
 use crate::{
@@ -381,7 +381,6 @@ impl<'tree, 'ir> IRBuilder<'tree, 'ir> {
 
                 self.tree.st.into_child(node);
                 let value = self.visit(*body);
-                // TODO: return value of body expression
                 self.tree.st.into_parent();
                 if value != !0 {
                     let ty = self.tree.type_of_node(*body);
@@ -946,259 +945,6 @@ impl<'tree, 'ir> IRBuilder<'tree, 'ir> {
     }
 }
 
-#[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-enum Registers {
-    A,
-    B,
-    C,
-    D,
-    SI,
-    DI,
-    R8,
-    R9,
-    R10,
-    R11,
-    R12,
-    R13,
-    R14,
-    R15,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum Width {
-    QWord,
-    DWord,
-    Word,
-    Byte,
-}
-
-impl Width {
-    fn from_size(size: u32) -> Option<Width> {
-        match size {
-            1 => Some(Self::Byte),
-            2 => Some(Self::Word),
-            3..=4 => Some(Self::DWord),
-            5..=8 => Some(Self::QWord),
-            _ => None,
-        }
-    }
-}
-
-struct RegisterDisplay {
-    reg: Registers,
-    width: Width,
-}
-
-impl core::fmt::Display for RegisterDisplay {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let prefix = match self.reg {
-            Registers::SI
-            | Registers::DI
-            | Registers::A
-            | Registers::B
-            | Registers::C
-            | Registers::D => match self.width {
-                Width::QWord => "r",
-                Width::DWord => "e",
-                Width::Word | Width::Byte => "",
-            },
-            Registers::R8
-            | Registers::R9
-            | Registers::R10
-            | Registers::R11
-            | Registers::R12
-            | Registers::R13
-            | Registers::R14
-            | Registers::R15 => "",
-        };
-        let suffix = match self.reg {
-            Registers::SI | Registers::DI => match self.width {
-                Width::QWord | Width::DWord | Width::Word => "",
-                Width::Byte => "l",
-            },
-            Registers::A | Registers::B | Registers::C | Registers::D => match self.width {
-                Width::QWord | Width::DWord | Width::Word => "x",
-                Width::Byte => "l",
-            },
-            Registers::R8
-            | Registers::R9
-            | Registers::R10
-            | Registers::R11
-            | Registers::R12
-            | Registers::R13
-            | Registers::R14
-            | Registers::R15 => match self.width {
-                Width::QWord => "",
-                Width::DWord => "d",
-                Width::Word => "w",
-                Width::Byte => "b",
-            },
-        };
-
-        let name = match self.reg {
-            Registers::A => "a",
-            Registers::B => "b",
-            Registers::C => "c",
-            Registers::D => "d",
-            Registers::SI => "si",
-            Registers::DI => "di",
-            Registers::R8 => "r8",
-            Registers::R9 => "r9",
-            Registers::R10 => "r10",
-            Registers::R11 => "r11",
-            Registers::R12 => "r12",
-            Registers::R13 => "r13",
-            Registers::R14 => "r14",
-            Registers::R15 => "r15",
-        };
-
-        write!(f, "{prefix}{name}{suffix}")
-    }
-}
-
-impl Registers {
-    fn display(self, width: Width) -> RegisterDisplay {
-        RegisterDisplay { reg: self, width }
-    }
-    fn all() -> [Registers; 14] {
-        [
-            Self::A,
-            Self::B,
-            Self::C,
-            Self::D,
-            Self::SI,
-            Self::DI,
-            Self::R8,
-            Self::R9,
-            Self::R10,
-            Self::R11,
-            Self::R12,
-            Self::R13,
-            Self::R14,
-            Self::R15,
-        ]
-    }
-
-    fn sysv_param_idx(idx: u32) -> Option<Registers> {
-        match idx {
-            0 => Some(Self::DI),
-            1 => Some(Self::SI),
-            2 => Some(Self::D),
-            3 => Some(Self::C),
-            4 => Some(Self::R8),
-            5 => Some(Self::R9),
-            _ => None,
-        }
-    }
-}
-
-struct RegisterStore {
-    registers: [Option<Registers>; 14],
-    used: BTreeSet<Registers>,
-}
-
-impl RegisterStore {
-    fn new() -> RegisterStore {
-        Self {
-            registers: Registers::all().map(|r| Some(r)),
-            used: BTreeSet::new(),
-        }
-    }
-    fn take_any(&mut self) -> Option<Registers> {
-        let a = self.registers.iter_mut().filter(|r| r.is_some()).next()?;
-        let reg = a.take()?;
-        self.used.insert(reg);
-        Some(reg)
-    }
-    fn force_take(&mut self, reg: Registers) {
-        self.registers[reg as usize] = None;
-    }
-    fn free(&mut self, reg: Registers) {
-        self.registers[reg as usize] = Some(reg);
-    }
-}
-
-struct StackMem {
-    offset: u32,
-}
-
-impl StackMem {
-    fn new(offset: u32) -> Self {
-        Self { offset }
-    }
-}
-
-impl core::fmt::Display for StackMem {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "[rbp - 0x{:x}]", self.offset)
-    }
-}
-
-enum ImmRegMem {
-    ImmU32(u32),
-    ImmU64(u64),
-    Mem(StackMem),
-    Reg(Registers, Width),
-}
-
-impl core::fmt::Display for ImmRegMem {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ImmRegMem::ImmU32(v) => write!(f, "0x{v:x}"),
-            ImmRegMem::ImmU64(v) => write!(f, "0x{v:x}"),
-            ImmRegMem::Mem(mem) => write!(f, "{mem}"),
-            ImmRegMem::Reg(reg, width) => write!(f, "{}", reg.display(*width)),
-        }
-    }
-}
-
-#[derive(Debug, Default)]
-struct Function {
-    name: String,
-    entry: String,
-    branches: HashMap<String, String>,
-    stack_size: u32,
-    used_registers: Vec<Registers>,
-}
-
-impl Function {
-    fn write<W: core::fmt::Write>(&self, w: &mut W) -> core::fmt::Result {
-        writeln!(w, "{}:", self.name)?;
-
-        for reg in self.used_registers.iter() {
-            writeln!(w, "push {}", reg.display(Width::QWord))?;
-        }
-
-        writeln!(w, "push rbp")?;
-        writeln!(w, "mov rbp, rsp")?;
-
-        write!(w, "{}", self.entry)?;
-
-        writeln!(w, "{}__body:", self.name)?;
-        write!(w, "{}", self.branches.get("main").unwrap())?;
-
-        for (name, content) in &self.branches {
-            if name != "main" {
-                writeln!(w, "{}__{name}:", self.name)?;
-                write!(w, "{content}")?;
-            }
-        }
-
-        writeln!(w, "{}__epilogue:", self.name)?;
-        writeln!(w, "mov rsp, rbp")?;
-        writeln!(w, "pop rbp")?;
-
-        for reg in self.used_registers.iter().rev() {
-            writeln!(w, "pop {}", reg.display(Width::QWord))?;
-        }
-
-        writeln!(w, "ret")?;
-
-        Ok(())
-    }
-}
-
 struct IRIter<'a> {
     ir: &'a IR,
     offset: usize,