merge updated changes

Author: Nikil-Shyamsunder

src/diagnostic.rs

@@ -166,7 +166,7 @@ impl DiagnosticHandler {
 
 #[cfg(test)]
 mod tests {
-    use crate::typecheck::*;
+    use crate::{serialize::tests::create_calyx_go_down_transaction, typecheck::*};
 
     use super::*;
     use baa::BitVecValue;
@@ -197,87 +197,9 @@ mod tests {
     }
 
     #[test]
-    fn serialize_calyx_go_done_transaction() {
-        // Manually create the expected result of parsing `calyx_go_done`.
-        // Note that the order in which things are created will be different in the parser.
-
-        // 1) declare symbols
-        let mut symbols = SymbolTable::default();
-        let mut handler: DiagnosticHandler = DiagnosticHandler::new();
-        let ii = symbols.add_without_parent("ii".to_string(), Type::BitVec(32));
-        let oo = symbols.add_without_parent("oo".to_string(), Type::BitVec(32));
-        assert_eq!(symbols["oo"], symbols[oo]);
-
-        // declare Calyx struct
-        let dut_struct = symbols.add_struct(
-            "Calyx".to_string(),
-            vec![
-                Field::new("ii".to_string(), Dir::In, Type::BitVec(32)),
-                Field::new("go".to_string(), Dir::In, Type::BitVec(1)),
-                Field::new("done".to_string(), Dir::Out, Type::BitVec(1)),
-                Field::new("oo".to_string(), Dir::Out, Type::BitVec(32)),
-            ],
-        );
-
-        let dut = symbols.add_without_parent("dut".to_string(), Type::Struct(dut_struct));
-        let dut_ii = symbols.add_with_parent("ii".to_string(), dut);
-        let dut_go = symbols.add_with_parent("go".to_string(), dut);
-        let dut_done = symbols.add_with_parent("done".to_string(), dut);
-        let dut_oo = symbols.add_with_parent("oo".to_string(), dut);
-        assert_eq!(symbols["dut.oo"], symbols[dut_oo]);
-        assert_eq!(symbols["oo"], symbols[oo]);
-
-        // create fileid and read file
-        let input =
-            std::fs::read_to_string("tests/calyx_go_done_struct.prot").expect("failed to load");
-        let calyx_fileid = handler.add_file("calyx_go_done.prot".to_string(), input);
-
-        // 2) create transaction
-        let mut calyx_go_done = Transaction::new("calyx_go_done".to_string());
-        calyx_go_done.args = vec![Arg::new(ii, Dir::In), Arg::new(oo, Dir::Out)];
-        calyx_go_done.type_args = vec![dut];
-
-        // 3) create expressions
-        let ii_expr = calyx_go_done.e(Expr::Sym(ii));
-        calyx_go_done.add_expr_loc(ii_expr, 153, 155, calyx_fileid);
-        let dut_oo_expr = calyx_go_done.e(Expr::Sym(dut_oo));
-        calyx_go_done.add_expr_loc(dut_oo_expr, 260, 266, calyx_fileid);
-        let one_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(1, 1)));
-        calyx_go_done.add_expr_loc(one_expr, 170, 171, calyx_fileid);
-        let zero_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(0, 1)));
-        calyx_go_done.add_expr_loc(zero_expr, 232, 233, calyx_fileid);
-        let dut_done_expr = calyx_go_done.e(Expr::Sym(dut_done));
-        calyx_go_done.add_expr_loc(dut_done_expr, 184, 192, calyx_fileid);
-        let cond_expr = calyx_go_done.e(Expr::Binary(BinOp::Equal, dut_done_expr, one_expr));
-        calyx_go_done.add_expr_loc(cond_expr, 183, 198, calyx_fileid);
-        let not_expr = calyx_go_done.e(Expr::Unary(UnaryOp::Not, cond_expr));
-        calyx_go_done.add_expr_loc(not_expr, 182, 198, calyx_fileid);
-
-        // 4) create statements
-        let while_body = vec![calyx_go_done.s(Stmt::Step)];
-        let wbody = calyx_go_done.s(Stmt::Block(while_body));
-
-        let dut_ii_assign = calyx_go_done.s(Stmt::Assign(dut_ii, ii_expr));
-        calyx_go_done.add_stmt_loc(dut_ii_assign, 143, 157, calyx_fileid);
-        let dut_go_assign = calyx_go_done.s(Stmt::Assign(dut_go, one_expr));
-        calyx_go_done.add_stmt_loc(dut_go_assign, 160, 172, calyx_fileid);
-        let dut_while = calyx_go_done.s(Stmt::While(not_expr, wbody));
-        calyx_go_done.add_stmt_loc(dut_while, 175, 219, calyx_fileid);
-        let dut_go_reassign = calyx_go_done.s(Stmt::Assign(dut_go, zero_expr));
-        calyx_go_done.add_stmt_loc(dut_go_reassign, 222, 234, calyx_fileid);
-        let dut_ii_dontcare = calyx_go_done.s(Stmt::Assign(dut_ii, calyx_go_done.expr_dont_care()));
-        calyx_go_done.add_stmt_loc(dut_ii_dontcare, 238, 250, calyx_fileid);
-        let oo_assign = calyx_go_done.s(Stmt::Assign(oo, dut_oo_expr));
-        calyx_go_done.add_stmt_loc(oo_assign, 254, 268, calyx_fileid);
-        let body = vec![
-            dut_ii_assign,
-            dut_go_assign,
-            dut_while,
-            dut_go_reassign,
-            dut_ii_dontcare,
-            oo_assign,
-        ];
-        calyx_go_done.body = calyx_go_done.s(Stmt::Block(body));
+    fn serialize_calyx_go_down_transaction() {
+        let mut handler = DiagnosticHandler::new();
+        let (calyx_go_done, symbols) = create_calyx_go_down_transaction(&mut handler);
         type_check(&calyx_go_done, &symbols, &mut handler);
     }
 }

src/ir.rs

@@ -131,6 +131,10 @@ impl Arg {
         self.dir
     }
 
+    pub fn symbol(&self) -> SymbolId {
+        self.symbol
+    }
+
     pub fn new(symbol: SymbolId, dir: Dir) -> Self {
         Self { dir, symbol }
     }
@@ -175,6 +179,7 @@ pub enum Stmt {
     Fork,
     While(ExprId, StmtId),
     IfElse(ExprId, StmtId, StmtId),
+    AssertEq(ExprId, ExprId),
 }
 
 #[derive(Clone, Copy, Hash, PartialEq, Eq, Default)]
@@ -439,6 +444,10 @@ impl SymbolTableEntry {
         self.tpe.clone()
     }
 
+    pub fn parent(&self) -> Option<SymbolId> {
+        self.parent
+    }
+
     /// full hierarchical name
     pub fn full_name(&self, symbols: &SymbolTable) -> String {
         let mut name = self.name.clone();

src/serialize.rs

@@ -10,7 +10,7 @@ use baa::BitVecOps;
 
 use crate::{diagnostic::*, ir::*};
 
-fn serialize_to_string(tr: &Transaction, st: &SymbolTable) -> std::io::Result<String> {
+pub fn serialize_to_string(tr: &Transaction, st: &SymbolTable) -> std::io::Result<String> {
     let mut out = Vec::new();
     serialize(&mut out, tr, st)?;
     let out = String::from_utf8(out).unwrap();
@@ -90,6 +90,15 @@ fn build_statements(
             build_statements(out, tr, st, elsebody, index + 1)?;
             writeln!(out, "{}}}", "  ".repeat(index))?;
         }
+        Stmt::AssertEq(exprid1, exprid2) => {
+            writeln!(
+                out,
+                "{}assert_eq({}, {});",
+                "  ".repeat(index),
+                serialize_expr(tr, st, exprid1),
+                serialize_expr(tr, st, exprid2)
+            )?;
+        }
     }
 
     Ok(())
@@ -179,9 +188,8 @@ pub mod tests {
 
     use super::*;
 
-    #[test]
-    fn serialize_add_transaction() {
-        // Manually create the expected result of parsing `addStruct.prot`.
+    pub fn create_add_transaction(handler: &mut DiagnosticHandler) -> (Transaction, SymbolTable) {
+        // Manually create the expected result of parsing `add.prot`.
         // Note that the order in which things are created will be different in the parser.
 
         // 1) declare symbols
@@ -209,6 +217,10 @@ pub mod tests {
         assert_eq!(symbols["DUT.s"], symbols[dut_s]);
         assert_eq!(symbols["s"], symbols[s]);
 
+        // create fileid and read file
+        let input = std::fs::read_to_string("tests/addStruct.prot").expect("failed to load");
+        let add_fileid = handler.add_file("add.prot".to_string(), input);
+
         // 2) create transaction
         let mut add = Transaction::new("add".to_string());
         add.args = vec![
@@ -220,31 +232,54 @@ pub mod tests {
 
         // 3) create expressions
         let a_expr = add.e(Expr::Sym(a));
+        add.add_expr_loc(a_expr, 193, 194, add_fileid);
         let b_expr = add.e(Expr::Sym(b));
+        add.add_expr_loc(b_expr, 208, 209, add_fileid);
         let dut_s_expr = add.e(Expr::Sym(dut_s));
+        add.add_expr_loc(dut_s_expr, 271, 276, add_fileid);
+        let s_expr = add.e(Expr::Sym(s));
 
         // 4) create statements
+        let a_assign = add.s(Stmt::Assign(dut_a, a_expr));
+        add.add_stmt_loc(a_assign, 184, 195, add_fileid);
+        let b_assign = add.s(Stmt::Assign(dut_b, b_expr));
+        add.add_stmt_loc(b_assign, 199, 210, add_fileid);
+        let step = add.s(Stmt::Step);
+        add.add_stmt_loc(step, 214, 221, add_fileid);
+        let fork = add.s(Stmt::Fork);
+        add.add_stmt_loc(fork, 225, 232, add_fileid);
+        let dut_a_assign = add.s(Stmt::Assign(dut_a, add.expr_dont_care()));
+        add.add_stmt_loc(dut_a_assign, 236, 247, add_fileid);
+        let dut_b_assign = add.s(Stmt::Assign(dut_b, add.expr_dont_care()));
+        add.add_stmt_loc(dut_b_assign, 251, 262, add_fileid);
+        let s_assign = add.s(Stmt::Assign(s, dut_s_expr));
+        add.add_stmt_loc(s_assign, 266, 277, add_fileid);
+        let dut_s_assign = add.s(Stmt::Assign(dut_s, a_expr));
+        add.add_stmt_loc(dut_s_assign, 281, 292, add_fileid);
+        let assert = add.s(Stmt::AssertEq(s_expr, dut_s_expr));
+        add.add_stmt_loc(assert, 296, 316, add_fileid);
         let body = vec![
-            add.s(Stmt::Assign(dut_a, a_expr)),
-            add.s(Stmt::Assign(dut_b, b_expr)),
-            add.s(Stmt::Step),
-            add.s(Stmt::Fork),
-            add.s(Stmt::Assign(dut_a, add.expr_dont_care())),
-            add.s(Stmt::Assign(dut_b, add.expr_dont_care())),
-            add.s(Stmt::Assign(s, dut_s_expr)),
+            a_assign,
+            b_assign,
+            step,
+            fork,
+            dut_a_assign,
+            dut_b_assign,
+            s_assign,
+            dut_s_assign,
+            assert,
         ];
         add.body = add.s(Stmt::Block(body));
 
-        println!("{}", serialize_to_string(&add, &symbols).unwrap());
+        (add, symbols)
     }
 
-    #[test]
-    fn serialize_calyx_go_done_transaction() {
-        // Manually create the expected result of parsing `calyx_go_done`.
+    pub fn create_calyx_go_down_transaction(
+        handler: &mut DiagnosticHandler,
+    ) -> (Transaction, SymbolTable) {
+        // Manually create the expected result of parsing `calyx_go_down`.
         // Note that the order in which things are created will be different in the parser.
 
-        // TODO: create this into function that factors our the code to put src code into IR
-
         // 1) declare symbols
         let mut symbols = SymbolTable::default();
         let ii = symbols.add_without_parent("ii".to_string(), Type::BitVec(32));
@@ -256,7 +291,7 @@ pub mod tests {
             "Calyx".to_string(),
             vec![
                 Field::new("ii".to_string(), Dir::In, Type::BitVec(32)),
-                Field::new("go".to_string(), Dir::In, Type::BitVec(1)),
+                Field::new("go".to_string(), Dir::In, Type::BitVec(32)),
                 Field::new("done".to_string(), Dir::Out, Type::BitVec(1)),
                 Field::new("oo".to_string(), Dir::Out, Type::BitVec(32)),
             ],
@@ -270,30 +305,48 @@ pub mod tests {
         assert_eq!(symbols["dut.oo"], symbols[dut_oo]);
         assert_eq!(symbols["oo"], symbols[oo]);
 
+        // create fileid and read file
+        let input =
+            std::fs::read_to_string("tests/calyx_go_doneStruct.prot").expect("failed to load");
+        let calyx_fileid = handler.add_file("calyx_go_done.prot".to_string(), input);
+
         // 2) create transaction
         let mut calyx_go_done = Transaction::new("calyx_go_done".to_string());
         calyx_go_done.args = vec![Arg::new(ii, Dir::In), Arg::new(oo, Dir::Out)];
         calyx_go_done.type_args = vec![dut];
 
         // 3) create expressions
         let ii_expr = calyx_go_done.e(Expr::Sym(ii));
+        calyx_go_done.add_expr_loc(ii_expr, 153, 155, calyx_fileid);
         let dut_oo_expr = calyx_go_done.e(Expr::Sym(dut_oo));
+        calyx_go_done.add_expr_loc(dut_oo_expr, 260, 266, calyx_fileid);
         let one_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(1, 1)));
+        calyx_go_done.add_expr_loc(one_expr, 170, 171, calyx_fileid);
         let zero_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(0, 1)));
+        calyx_go_done.add_expr_loc(zero_expr, 232, 233, calyx_fileid);
         let dut_done_expr = calyx_go_done.e(Expr::Sym(dut_done));
-        let cond_expr = calyx_go_done.e(Expr::Binary(BinOp::Equal, dut_done_expr, one_expr));
-        let not_expr = calyx_go_done.e(Expr::Unary(UnaryOp::Not, cond_expr));
+        calyx_go_done.add_expr_loc(dut_done_expr, 184, 192, calyx_fileid);
+        let cond_expr = calyx_go_done.e(Expr::Equal(dut_done_expr, one_expr));
+        calyx_go_done.add_expr_loc(cond_expr, 183, 198, calyx_fileid);
+        let not_expr = calyx_go_done.e(Expr::Not(cond_expr));
+        calyx_go_done.add_expr_loc(not_expr, 182, 198, calyx_fileid);
 
         // 4) create statements
         let while_body: Vec<StmtId> = vec![calyx_go_done.s(Stmt::Step)];
         let wbody = calyx_go_done.s(Stmt::Block(while_body));
 
         let dut_ii_assign = calyx_go_done.s(Stmt::Assign(dut_ii, ii_expr));
-        let dut_go_assign = calyx_go_done.s(Stmt::Assign(dut_go, one_expr));
+        calyx_go_done.add_stmt_loc(dut_ii_assign, 143, 157, calyx_fileid);
+        let dut_go_assign = calyx_go_done.s(Stmt::Assign(dut_go, one_expr)); // Should cause type mismatch error
+        calyx_go_done.add_stmt_loc(dut_go_assign, 160, 172, calyx_fileid);
         let dut_while = calyx_go_done.s(Stmt::While(not_expr, wbody));
-        let dut_go_reassign = calyx_go_done.s(Stmt::Assign(dut_go, zero_expr));
+        calyx_go_done.add_stmt_loc(dut_while, 175, 219, calyx_fileid);
+        let dut_go_reassign = calyx_go_done.s(Stmt::Assign(dut_go, zero_expr)); // Should cause type mismatch error
+        calyx_go_done.add_stmt_loc(dut_go_reassign, 222, 234, calyx_fileid);
         let dut_ii_dontcare = calyx_go_done.s(Stmt::Assign(dut_ii, calyx_go_done.expr_dont_care()));
+        calyx_go_done.add_stmt_loc(dut_ii_dontcare, 238, 250, calyx_fileid);
         let oo_assign = calyx_go_done.s(Stmt::Assign(oo, dut_oo_expr));
+        calyx_go_done.add_stmt_loc(oo_assign, 254, 268, calyx_fileid);
         let body = vec![
             dut_ii_assign,
             dut_go_assign,
@@ -303,6 +356,22 @@ pub mod tests {
             oo_assign,
         ];
         calyx_go_done.body = calyx_go_done.s(Stmt::Block(body));
+
+        (calyx_go_done, symbols)
+    }
+
+    #[test]
+    fn serialize_add_transaction() {
+        let mut handler = DiagnosticHandler::new();
+        let (add, symbols) = create_add_transaction(&mut handler);
+
+        println!("{}", serialize_to_string(&add, &symbols).unwrap());
+    }
+
+    #[test]
+    fn serialize_calyx_go_down_transaction() {
+        let mut handler = DiagnosticHandler::new();
+        let (calyx_go_done, symbols) = create_calyx_go_down_transaction(&mut handler);
         println!("{}", serialize_to_string(&calyx_go_done, &symbols).unwrap());
     }