Change Expr type to have Binary and Unary variants

Author: Nikil-Shyamsunder

src/ir.rs

@@ -181,19 +181,33 @@ pub enum Stmt {
 pub struct ExprId(u32);
 entity_impl!(ExprId, "expr");
 
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub enum BinOp {
+    Equal,
+    And,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub enum UnaryOp {
+    Not,
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum Expr {
     // nullary
     Const(BitVecValue),
     Sym(SymbolId),
     DontCare,
     // unary
-    Not(ExprId),
+    Binary(BinOp, ExprId, ExprId),
     // binary
-    And(ExprId, ExprId),
-    Equal(ExprId, ExprId),
+    Unary(UnaryOp, ExprId),
 }
 
+
+
+// add further bin ops
+
 #[derive(Clone, Copy, Hash, PartialEq, Eq, Default)]
 pub struct StructId(u32);
 entity_impl!(StructId, "struct");
@@ -337,7 +351,7 @@ impl Index<SymbolId> for SymbolTable {
     fn index(&self, index: SymbolId) -> &Self::Output {
         &self.entries[index]
     }
-}
+} 
 
 impl Index<&SymbolId> for SymbolTable {
     type Output = SymbolTableEntry;
@@ -468,8 +482,8 @@ mod tests {
     }
 
     #[test]
-    fn serialize_calyx_go_down_transaction() {
-        // Manually create the expected result of parsing `calyx_go_down`.
+    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
@@ -508,8 +522,8 @@ mod tests {
         let one_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(1, 1)));
         let zero_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(0, 1)));
         let dut_done_expr = calyx_go_done.e(Expr::Sym(dut_done));
-        let cond_expr = calyx_go_done.e(Expr::Equal(dut_done_expr, one_expr));
-        let not_expr = calyx_go_done.e(Expr::Not(cond_expr));
+        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));
 
         // 4) create statements
         let while_body = vec![calyx_go_done.s(Stmt::Step)];

src/serialize.rs

@@ -37,9 +37,9 @@ pub fn serialize_expr(tr: &Transaction, st: &SymbolTable, expr_id: &ExprId) -> S
         Expr::Const(val) => val.to_bit_str(),
         Expr::Sym(symid) => st[symid].full_name(st),
         Expr::DontCare => "X".to_owned(),
-        Expr::Not(not_exprid) => "!(".to_owned() + &serialize_expr(tr, st, not_exprid) + ")",
-        Expr::And(lhs, rhs) => serialize_expr(tr, st, lhs) + " && " + &serialize_expr(tr, st, rhs),
-        Expr::Equal(lhs, rhs) => {
+        Expr::Unary(UnaryOp::Not, not_exprid) => "!(".to_owned() + &serialize_expr(tr, st, not_exprid) + ")",
+        Expr::Binary(BinOp::And,lhs, rhs) => serialize_expr(tr, st, lhs) + " && " + &serialize_expr(tr, st, rhs),
+        Expr::Binary(BinOp::Equal, lhs, rhs) => {
             serialize_expr(tr, st, lhs) + " == " + &serialize_expr(tr, st, rhs)
         }
     }
@@ -239,8 +239,8 @@ pub mod tests {
     }
 
     #[test]
-    fn serialize_calyx_go_down_transaction() {
-        // Manually create the expected result of parsing `calyx_go_down`.
+    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.
 
         // TODO: create this into function that factors our the code to put src code into IR
@@ -281,8 +281,8 @@ pub mod tests {
         let one_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(1, 1)));
         let zero_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(0, 1)));
         let dut_done_expr = calyx_go_done.e(Expr::Sym(dut_done));
-        let cond_expr = calyx_go_done.e(Expr::Equal(dut_done_expr, one_expr));
-        let not_expr = calyx_go_done.e(Expr::Not(cond_expr));
+        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));
 
         // 4) create statements
         let while_body = vec![calyx_go_done.s(Stmt::Step)];
@@ -338,7 +338,7 @@ pub mod tests {
         let a_expr = easycond.e(Expr::Sym(a));
         let dut_a_expr = easycond.e(Expr::Sym(dut_a));
         let one_expr = easycond.e(Expr::Const(BitVecValue::from_u64(1, 1)));
-        let cond_expr = easycond.e(Expr::Equal(dut_a_expr, one_expr));
+        let cond_expr = easycond.e(Expr::Binary(BinOp::Equal, dut_a_expr, one_expr));
 
         // 4) create statements
         let if_body = vec![easycond.s(Stmt::Step)];

src/typecheck.rs

@@ -16,7 +16,7 @@ fn check_expr_types(
         Expr::Const(_) => Ok(Type::BitVec(1)),
         Expr::Sym(symid) => Ok(st[symid].tpe()),
         Expr::DontCare => Ok(Type::Unknown),
-        Expr::Not(not_exprid) => {
+        Expr::Unary(UnaryOp::Not, not_exprid) => {
             let inner_type = check_expr_types(tr, st, handler, not_exprid)?;
             if let Type::BitVec(_) = inner_type {
                 Ok(inner_type)
@@ -30,7 +30,7 @@ fn check_expr_types(
                 Ok(inner_type)
             }
         }
-        Expr::And(lhs, rhs) | Expr::Equal(lhs, rhs) => {
+        Expr::Binary(BinOp::And, lhs, rhs) | Expr::Binary(BinOp::Equal, lhs, rhs) => {
             let lhs_type = check_expr_types(tr, st, handler, lhs)?;
             let rhs_type = check_expr_types(tr, st, handler, rhs)?;
             if lhs_type.is_equivalent(&rhs_type) {
@@ -190,9 +190,9 @@ mod tests {
         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::Equal(dut_done_expr, one_expr));
+        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::Not(cond_expr));
+        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