added ir verifier

Author: DigitalCodeCrafter

src/ir/lowerer.rs

@@ -27,7 +27,7 @@ impl BlockId {
     pub fn index(&self) -> u32 { self.0 }
 }
 
-pub struct FunctionIRBuilder<'a> {
+struct FunctionIRBuilder<'a> {
     locals: Vec<Local>,
     temps: Vec<Temp>,
     blocks: Vec<Block>,
@@ -38,7 +38,7 @@ pub struct FunctionIRBuilder<'a> {
     env: HashMap<SymbolId, LocalId>,
 }
 impl<'a> FunctionIRBuilder<'a> {
-    pub fn new(symbols: &'a SymbolTable) -> Self {
+    fn new(symbols: &'a SymbolTable) -> Self {
         Self {
             locals: Vec::new(),
             temps: Vec::new(),
@@ -54,13 +54,13 @@ impl<'a> FunctionIRBuilder<'a> {
         }
     }
 
-    pub fn lower_function(&mut self, ast: t::TypedAst) {
+    fn lower_function(&mut self, ast: t::TypedAst) {
         for stmt in ast.stmts {
             self.lower_stmt(stmt);
         }
     }
 
-    pub fn finish(mut self) -> FunctionIR {
+    fn finish(mut self) -> FunctionIR {
         self.blocks[self.current_block.0 as usize].terminator = Terminator::Return(Value::Const(Const::Unit));
         FunctionIR {
             blocks: self.blocks,

src/ir/mod.rs

@@ -1,5 +1,6 @@
 mod ir;
 mod lowerer;
+mod verifier;
 pub mod pretty;
 
 pub use ir::*;

src/ir/verifier.rs

@@ -0,0 +1,82 @@
+use std::collections::HashSet;
+use crate::ir::{ir::*, lowerer::TempId};
+
+pub fn verify_ir(ir: &ProgramIR) {
+    for func in &ir.functions {
+        let mut verifier = FunctionIRVerifier { ir: func, defined: HashSet::new() };
+        verifier.verify_entry_exists();
+        for block in &func.blocks {
+            verifier.verify_block(block);
+        }
+    }
+}
+
+struct FunctionIRVerifier<'a> {
+    ir: &'a FunctionIR,
+    defined: HashSet<TempId>,
+}
+
+impl FunctionIRVerifier<'_> {
+    fn verify_entry_exists(&self) {
+        self.ir.blocks.len() > 0;
+    }
+
+    fn verify_temp(&self, id: TempId) {
+        self.defined.contains(&id);
+    }
+
+    fn verify_temp_def(&mut self, id: TempId) {
+        self.ir.temps.len() > id.index();
+        self.defined.insert(id);
+    }
+
+    fn verify_instr(&mut self, instr: &Instr) {
+        match instr {
+            Instr::LoadConst { dst, .. } => {
+                self.verify_temp_def(*dst)
+            }
+            Instr::Binary { dst, lhs, rhs, .. } {
+                self.verify_temp(*lhs);
+                self.verify_temp(*rhs);
+                self.verify_temp_def(*dst);
+            }
+            Instr::Store { place, value } => {
+                match value {
+                    Value::Temp(*id) => self.verify_temp(*id),
+                    _ => {}
+                }
+
+                match place {
+                    Place::Local(id) => self.ir.locals.len() > id.index(),
+                };
+            }
+            Instr::Load { dst, place } => {
+                match place {
+                    Place::Local(id) => self.ir.locals.len() > id.index(),
+                };
+                self.verify_temp_def(dst)
+            }
+            Instr::Poision { dst } => {
+                if let Some(id) = dst {
+                    self.verify_temp_def(*id)
+                }
+            }
+        }
+    }
+
+    fn verify_terminator(&self, term: &Terminator) {
+        match term {
+            Goto(id) => { self.ir.blocks.len() > id.len(); },
+            Return(Value::Temp(id)) => self.verify_temp(*id),
+            _ => {}
+        }
+    }
+
+    fn verify_block(&mut self, block: &Block) {
+        for instr in &block.instrs {
+            self.verify_instr(instr);
+        }
+        self.verify_terminator(&block.terminator)
+    }
+}
+

src/semantics/resolver.rs

@@ -99,7 +99,7 @@ impl ScopeGraph {
 
 // Resolution
 
-pub struct Resolver<'d, D: DiagnosticSink> {
+struct Resolver<'d, D: DiagnosticSink> {
     scopes: ScopeGraph,
     symbols: SymbolTable,
     diags: &'d mut D,
@@ -108,7 +108,7 @@ pub struct Resolver<'d, D: DiagnosticSink> {
 }
 
 impl<'d, D: DiagnosticSink> Resolver<'d, D> {
-    pub fn new(diags: &'d mut D) -> Self {
+    fn new(diags: &'d mut D) -> Self {
         let mut scopes = ScopeGraph { scopes: Vec::new() };
         let global = scopes.new_scope(None);
 
@@ -120,7 +120,7 @@ impl<'d, D: DiagnosticSink> Resolver<'d, D> {
         }
     }
 
-    pub fn resolve_program(&mut self, ast: p::ParsedAst) -> r::ResolvedAst {
+    fn resolve_program(&mut self, ast: p::ParsedAst) -> r::ResolvedAst {
         for stmt in &ast.stmts {
             self.declare_stmt(stmt);
         }

src/semantics/typechecker.rs

@@ -24,20 +24,20 @@ pub enum TypeError {
     UntypedSymbol(Span),
 }
 
-pub struct TypeChecker<'a> {
+struct TypeChecker<'a> {
     symbols: &'a mut SymbolTable,
     errors: Vec<TypeError>
 }
 
 impl<'a> TypeChecker<'a> {
-    pub fn new(symbols: &'a mut SymbolTable) -> Self {
+    fn new(symbols: &'a mut SymbolTable) -> Self {
         Self {
             symbols,
             errors: Vec::new(),
         }
     }
 
-    pub fn type_check(&mut self, ast: r::ResolvedAst) -> t::TypedAst {
+    fn type_check(&mut self, ast: r::ResolvedAst) -> t::TypedAst {
         let typed_stmts = ast.stmts
             .into_iter()
             .map(|stmt| self.check_stmt(stmt));

src/syntax/parser.rs

@@ -33,20 +33,20 @@ impl<'a, 'd, D: DiagnosticSink> Operator<'a, 'd, D> {
     }
 }
 
-pub struct Parser<'a, 'd, D: DiagnosticSink> {
+struct Parser<'a, 'd, D: DiagnosticSink> {
     stream: TokenStream<'a>,
     diags: &'d mut D,
 }
 
 impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
-    pub fn new(stream: TokenStream<'a>, diags: &'d mut D) -> Self {
+    fn new(stream: TokenStream<'a>, diags: &'d mut D) -> Self {
         Self {
             stream,
             diags,
         }
     }
 
-    pub fn parse_program(&mut self) -> ParsedAst<'a> {
+    fn parse_program(&mut self) -> ParsedAst<'a> {
         let mut stmts = Vec::new();
 
         while !matches!(self.stream.peek_with(LexHint::Any).map(|t| t.kind), Some(TokenKind::EOF) | None) {