Verification pass (#73)

* Define VerificationCtx

* Define trait VerificationPass

crates/verifier/src/ctx.rs

@@ -0,0 +1,34 @@
+//! Verification context
+
+use sonatina_ir::{ControlFlowGraph, Function};
+
+use crate::{error::ErrorData, ErrorStack};
+
+pub struct VerificationCtx<'a> {
+ pub func: &'a Function,
+ pub cfg: ControlFlowGraph,
+ pub error_stack: ErrorStack,
+}
+
+impl<'a> VerificationCtx<'a> {
+ pub fn new(func: &'a Function) -> Self {
+ let mut cfg = ControlFlowGraph::new();
+ cfg.compute(func);
+
+ Self {
+ func,
+ cfg,
+ error_stack: ErrorStack::default(),
+ }
+ }
+
+ pub fn report_nonfatal(&mut self, errs: &[ErrorData]) {
+ for e in errs {
+ let _err_ref = self.error_stack.push(*e);
+ }
+ }
+
+ pub fn report_fatal(&mut self, e: ErrorData) {
+ self.error_stack.fatal_error = Some(e);
+ }
+}

crates/verifier/src/error_stack.rs

@@ -5,21 +5,30 @@ use crate::error::{Error, ErrorData, ErrorRef};
 
 #[derive(Debug, Default)]
 pub struct ErrorStack {
- pub errors: PrimaryMap<ErrorRef, ErrorData>,
+ pub fatal_error: Option<ErrorData>,
+ pub non_fatal_errors: PrimaryMap<ErrorRef, ErrorData>,
 }
 
 impl ErrorStack {
  pub fn push(&mut self, err: ErrorData) -> ErrorRef {
- self.errors.push(err)
+ self.non_fatal_errors.push(err)
  }
 
  pub fn into_errs_iter(
  self,
  func: &Function,
  func_ref: FuncRef,
  ) -> impl IntoIterator<Item = Error<'_>> {
- self.errors
- .into_iter()
+ let Self {
+ fatal_error,
+ non_fatal_errors: mut errs,
+ } = self;
+
+ if let Some(err) = fatal_error {
+ errs.push(err);
+ }
+
+ errs.into_iter()
  .map(move |(_, err)| Error::new(err, func, func_ref))
  }
 }

crates/verifier/src/lib.rs

@@ -1,2 +1,8 @@
+pub mod ctx;
 pub mod error;
 pub mod error_stack;
+pub mod pass;
+
+pub use ctx::VerificationCtx;
+pub use error_stack::ErrorStack;
+pub use pass::VerificationPass;

crates/verifier/src/pass.rs

@@ -0,0 +1,7 @@
+//! Verification pass
+
+use crate::VerificationCtx;
+
+pub trait VerificationPass {
+ fn run(&mut self, ctx: VerificationCtx);
+}