Add more order of operation comparisons

src/subset/helpers.rs

@@ -264,7 +264,10 @@ impl Expr {
     }
 
     pub fn new_ipath_with_index(path: &str, index: &str) -> Expr {
-        Expr::IPath(InstancePath::new(path), Some(Rc::new(Expr::new_ref(index))))
+        Expr::IPath(
+            InstancePath::new(path),
+            Some(Rc::new(Expr::new_ref(index))),
+        )
     }
 
     pub fn new_call(name: &str, params: Vec<Expr>) -> Expr {

src/subset/pretty_print.rs

@@ -1,5 +1,7 @@
 use crate::subset::ast::*;
-use crate::util::pretty_print::{block, intersperse, PrettyHelper, PrettyPrint};
+use crate::util::pretty_print::{
+    block, intersperse, PrettyHelper, PrettyPrint,
+};
 use core::cmp::Ordering;
 use itertools::Itertools;
 use pretty::RcDoc;
@@ -8,32 +10,32 @@ use pretty::RcDoc;
 /// operator with stronger binding.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 enum ParenCtx {
-    Op,
     Not,
-    And,
-    Or,
+    Index,
+    Mul,
+    AddSub,
+    Shift,
+    Cmp,
+    Equal,
     BAnd,
     BOr,
+    And,
+    Or,
 }
 
 impl From<&Binop> for ParenCtx {
     fn from(s: &Binop) -> Self {
         match s {
-            Binop::BitOr => ParenCtx::BOr,
+            Binop::IndexBit => ParenCtx::Index,
+            Binop::Mul => ParenCtx::Mul,
+            Binop::Add | Binop::Sub => ParenCtx::AddSub,
+            Binop::ShiftLeft => ParenCtx::Shift,
+            Binop::Lt | Binop::Gt | Binop::Geq | Binop::Leq => ParenCtx::Cmp,
+            Binop::Equal | Binop::NotEqual => ParenCtx::Equal,
             Binop::BitAnd => ParenCtx::BAnd,
-            Binop::LogOr => ParenCtx::Or,
+            Binop::BitOr => ParenCtx::BOr,
             Binop::LogAnd => ParenCtx::And,
-            Binop::Add
-            | Binop::Sub
-            | Binop::Mul
-            | Binop::Lt
-            | Binop::Gt
-            | Binop::Geq
-            | Binop::Leq
-            | Binop::Equal
-            | Binop::NotEqual
-            | Binop::IndexBit
-            | Binop::ShiftLeft => ParenCtx::Op,
+            Binop::LogOr => ParenCtx::Or,
         }
     }
 }
@@ -47,18 +49,63 @@ impl Ord for ParenCtx {
         match (self, other) {
             (P::Not, _) => Ordering::Greater,
 
-            (P::Op, P::Not) => Ordering::Less,
-            (P::Op, _) => Ordering::Greater,
+            (P::Index, P::Not) => Ordering::Less,
+            (P::Index, _) => Ordering::Greater,
+
+            (P::Mul, P::Not) | (P::Mul, P::Index) => Ordering::Less,
+            (P::Mul, _) => Ordering::Greater,
+
+            (P::AddSub, P::Not)
+            | (P::AddSub, P::Index)
+            | (P::AddSub, P::Mul) => Ordering::Less,
+            (P::AddSub, _) => Ordering::Greater,
+
+            (P::Shift, P::Not)
+            | (P::Shift, P::Index)
+            | (P::Shift, P::Mul)
+            | (P::Shift, P::AddSub) => Ordering::Less,
+            (P::Shift, _) => Ordering::Greater,
 
-            (P::BAnd, P::Not) | (P::BAnd, P::Op) => Ordering::Less,
+            (P::Cmp, P::Not)
+            | (P::Cmp, P::Index)
+            | (P::Cmp, P::Mul)
+            | (P::Cmp, P::AddSub)
+            | (P::Cmp, P::Shift) => Ordering::Greater,
+            (P::Cmp, _) => Ordering::Less,
+
+            (P::Equal, P::Not)
+            | (P::Equal, P::Index)
+            | (P::Equal, P::Mul)
+            | (P::Equal, P::AddSub)
+            | (P::Equal, P::Shift)
+            | (P::Equal, P::Cmp) => Ordering::Greater,
+            (P::Equal, _) => Ordering::Less,
+
+            (P::BAnd, P::Not)
+            | (P::BAnd, P::Mul)
+            | (P::BAnd, P::AddSub)
+            | (P::BAnd, P::Shift)
+            | (P::BAnd, P::Cmp)
+            | (P::BAnd, P::Equal) => Ordering::Less,
             (P::BAnd, _) => Ordering::Greater,
 
-            (P::BOr, P::Not) | (P::BOr, P::Op) | (P::BOr, P::BAnd) => Ordering::Less,
+            (P::BOr, P::Not)
+            | (P::BOr, P::Mul)
+            | (P::BOr, P::AddSub)
+            | (P::BOr, P::Shift)
+            | (P::BOr, P::Cmp)
+            | (P::BOr, P::Equal)
+            | (P::BOr, P::BAnd) => Ordering::Less,
             (P::BOr, _) => Ordering::Greater,
 
-            (P::And, P::Not) | (P::And, P::Op) | (P::And, P::BAnd) | (P::And, P::BOr) => {
-                Ordering::Less
-            }
+            (P::And, P::Not)
+            | (P::And, P::Mul)
+            | (P::And, P::AddSub)
+            | (P::And, P::Shift)
+            | (P::And, P::Cmp)
+            | (P::And, P::Equal)
+            | (P::And, P::BOr)
+            | (P::And, P::BAnd) => Ordering::Less,
             (P::And, _) => Ordering::Greater,
 
             (P::Or, _) => Ordering::Less,
@@ -174,7 +221,9 @@ impl PrettyPrint for Expr {
                     path.to_doc()
                 }
             }
-            Expr::Unop(op, input) => op.to_doc().append(print_expr(input, ParenCtx::Not)),
+            Expr::Unop(op, input) => {
+                op.to_doc().append(print_expr(input, ParenCtx::Not))
+            }
             Expr::Binop(Binop::IndexBit, lhs, rhs) => {
                 print_expr(lhs, ParenCtx::Not).append(rhs.to_doc().brackets())
             }
@@ -207,15 +256,17 @@ impl PrettyPrint for Expr {
                     .append(lo.to_doc())
                     .brackets(),
             ),
-            Expr::Terop(Terop::IndexSlice, var, lo, width) => var.to_doc().append(
-                lo.to_doc()
-                    .append(RcDoc::space())
-                    .append(RcDoc::text("+"))
-                    .append(RcDoc::text(":"))
-                    .append(RcDoc::space())
-                    .append(width.to_doc())
-                    .brackets(),
-            ),
+            Expr::Terop(Terop::IndexSlice, var, lo, width) => {
+                var.to_doc().append(
+                    lo.to_doc()
+                        .append(RcDoc::space())
+                        .append(RcDoc::text("+"))
+                        .append(RcDoc::text(":"))
+                        .append(RcDoc::space())
+                        .append(width.to_doc())
+                        .brackets(),
+                )
+            }
             Expr::Concat(concat) => concat.to_doc(),
             Expr::Repeat(times, expr) => RcDoc::text(times.to_string())
                 .append(expr.to_doc().braces())
@@ -269,13 +320,13 @@ impl PrettyPrint for AssignTy {
 impl PrettyPrint for Map {
     fn to_doc(&self) -> RcDoc<()> {
         intersperse(
-            self.iter()
-                .sorted_by_key(|(id, _)| (*id).clone())
-                .map(|(id, expr)| {
+            self.iter().sorted_by_key(|(id, _)| (*id).clone()).map(
+                |(id, expr)| {
                     RcDoc::text(".")
                         .append(RcDoc::as_string(id))
                         .append(expr.to_doc().parens())
-                }),
+                },
+            ),
             RcDoc::text(",").append(RcDoc::hardline()),
         )
     }

src/util/pretty_print.rs

@@ -63,7 +63,10 @@ impl<'a, A> PrettyHelper<'a> for RcDoc<'a, A> {
     }
 }
 
-pub fn intersperse<'a>(iter: impl Iterator<Item = RcDoc<'a>>, separator: RcDoc<'a>) -> RcDoc<'a> {
+pub fn intersperse<'a>(
+    iter: impl Iterator<Item = RcDoc<'a>>,
+    separator: RcDoc<'a>,
+) -> RcDoc<'a> {
     RcDoc::intersperse(iter, separator)
 }
 

src/v05/helpers.rs

@@ -33,11 +33,18 @@ impl Decl {
     }
 
     pub fn new_array(name: &str, width: u64, depth: u64) -> Decl {
-        Decl::Array(name.to_string(), Ty::new_width(width), Ty::new_width(depth))
+        Decl::Array(
+            name.to_string(),
+            Ty::new_width(width),
+            Ty::new_width(depth),
+        )
     }
 
     pub fn new_param_uint(name: &str, value: u32) -> Decl {
-        Decl::Param(name.to_string(), Expr::new_ulit_dec(32, &value.to_string()))
+        Decl::Param(
+            name.to_string(),
+            Expr::new_ulit_dec(32, &value.to_string()),
+        )
     }
 
     pub fn new_param_str(name: &str, value: &str) -> Decl {

src/v05/pretty_print.rs

@@ -1,5 +1,7 @@
 // use crate::util::pretty_print::{PrettyHelper, PrettyPrint, PRETTY_INDENT};
-use crate::util::pretty_print::{block, block_with_parens, intersperse, PrettyHelper, PrettyPrint};
+use crate::util::pretty_print::{
+    block, block_with_parens, intersperse, PrettyHelper, PrettyPrint,
+};
 use crate::v05::ast::*;
 use pretty::RcDoc;
 
@@ -114,7 +116,9 @@ impl PrettyPrint for Sequential {
         match self {
             // wildcard for sensitivity list
             Sequential::Wildcard => RcDoc::text("*"),
-            Sequential::Event(ty, expr) => ty.to_doc().append(RcDoc::space()).append(expr.to_doc()),
+            Sequential::Event(ty, expr) => {
+                ty.to_doc().append(RcDoc::space()).append(expr.to_doc())
+            }
             Sequential::IfElse(ifelse) => ifelse.to_doc(),
             Sequential::Assign(lexpr, rexpr, ty) => lexpr
                 .to_doc()

src/v17/ast.rs

@@ -11,7 +11,8 @@ pub type Instance = subset::ast::Instance;
 pub type CaseBranch = subset::ast::GenericCaseBranch<Sequential>;
 pub type CaseDefault = subset::ast::GenericCaseDefault<Sequential>;
 pub type Case = subset::ast::GenericCase<Sequential>;
-pub type Function = subset::ast::GenericFunction<FunctionTy, Decl, Sequential, Ty>;
+pub type Function =
+    subset::ast::GenericFunction<FunctionTy, Decl, Sequential, Ty>;
 pub type Stmt = subset::ast::GenericStmt<Decl, Parallel>;
 pub type Port = subset::ast::GenericPort<Decl>;
 pub type Module = subset::ast::GenericModule<Decl, Parallel>;

src/v17/pretty_print.rs

@@ -1,5 +1,7 @@
 use crate::subset::ast::Terop;
-use crate::util::pretty_print::{block, block_with_parens, intersperse, PrettyHelper, PrettyPrint};
+use crate::util::pretty_print::{
+    block, block_with_parens, intersperse, PrettyHelper, PrettyPrint,
+};
 use crate::v17::ast::*;
 use pretty::RcDoc;
 
@@ -106,7 +108,10 @@ impl PrettyPrint for Function {
         let body = if self.body().is_empty() {
             RcDoc::nil()
         } else {
-            intersperse(self.body().iter().map(|x| x.to_doc()), RcDoc::hardline())
+            intersperse(
+                self.body().iter().map(|x| x.to_doc()),
+                RcDoc::hardline(),
+            )
         };
         let args = RcDoc::space()
             .append(self.ret.to_doc())
@@ -195,7 +200,9 @@ impl PrettyPrint for Sequential {
                 .append(RcDoc::text(";")),
             Sequential::SeqCase(case) => case.to_doc(),
             Sequential::Call(call) => call.to_doc().append(RcDoc::text(";")),
-            Sequential::Event(ty, expr) => ty.to_doc().append(RcDoc::space()).append(expr.to_doc()),
+            Sequential::Event(ty, expr) => {
+                ty.to_doc().append(RcDoc::space()).append(expr.to_doc())
+            }
             Sequential::Assert(expr, branch) => {
                 let cond = RcDoc::text("assert").append(expr.to_doc().parens());
                 if let Some(block) = branch {

tests/v05.rs

@@ -166,6 +166,18 @@ fn test_decl_array() {
     check!(decl, exp);
 }
 
+#[test]
+fn test_bit_shift_order_of_operations() {
+    let bin1 = Expr::new_ulit_bin(4, "1000");
+    let bin2 = Expr::new_ulit_bin(4, "0100");
+    let shift_by: i32 = 2;
+    let shift = Expr::new_shift_left(bin1, shift_by);
+    let add = Expr::new_add(bin2, shift);
+    let exp = "4'b0100 + (4'b1000 << 2)".to_string();
+    let res = add.to_string();
+    check!(res, exp);
+}
+
 #[test]
 fn test_event_ty_posedge() {
     let event = EventTy::Posedge;
@@ -184,7 +196,8 @@ fn test_event_ty_negedge() {
 
 #[test]
 fn test_sequential_event_posedge_clock() {
-    let seq = Sequential::Event(EventTy::Posedge, Expr::Ref("clock".to_string()));
+    let seq =
+        Sequential::Event(EventTy::Posedge, Expr::Ref("clock".to_string()));
     let exp = "posedge clock".to_string();
     let res = seq.to_string();
     check!(res, exp);
@@ -280,7 +293,8 @@ end"#;
 fn test_attribute_decl() {
     let mut attr = Attribute::default();
     attr.add_stmt("ram_style", "block");
-    let decl = Decl::new_attribute_decl(attr, Decl::new_reg("ram", 32)).to_string();
+    let decl =
+        Decl::new_attribute_decl(attr, Decl::new_reg("ram", 32)).to_string();
     let gold = r#"(*ram_style = "block"*) reg [31:0] ram"#;
     check!(decl, gold);
 }

tests/v17.rs

@@ -324,7 +324,8 @@ end"#;
 
 #[test]
 fn test_seq_event_posedge_clock() {
-    let event = Sequential::Event(EventTy::Posedge, Expr::Ref("clock".to_string()));
+    let event =
+        Sequential::Event(EventTy::Posedge, Expr::Ref("clock".to_string()));
     let res = event.to_string();
     let exp = "posedge clock".to_string();
     check!(res, exp);
@@ -623,7 +624,8 @@ fn test_module_with_always_comb() {
 #[test]
 fn test_module_with_always_ff() {
     let exp = read_to_string("regression/v17/module_with_always_ff.v");
-    let event = Sequential::Event(EventTy::Posedge, Expr::Ref("clock".to_string()));
+    let event =
+        Sequential::Event(EventTy::Posedge, Expr::Ref("clock".to_string()));
     let mut always = ParallelProcess::new_always_ff();
     always.add_seq(Sequential::new_display("hello sync world"));
     always.set_event(event);