Add logical and comparison expressions

crates/decodal-core/src/parser.rs

@@ -147,6 +147,70 @@ impl Parser {
                     },
                     span,
                 ),
+                InfixKind::Equal => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::Equal,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::NotEqual => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::NotEqual,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::Greater => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::Greater,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::GreaterEqual => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::GreaterEqual,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::Less => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::Less,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::LessEqual => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::LessEqual,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::LogicalAnd => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::LogicalAnd,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::LogicalOr => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::LogicalOr,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
                 InfixKind::And => self.ast.push(
                     Expr::Binary {
                         op: BinaryOp::And,
@@ -206,7 +270,7 @@ impl Parser {
             TokenKind::Match => self.parse_match(token.span),
             TokenKind::Import => self.parse_import(token.span),
             TokenKind::Minus => {
-                let expr = self.parse_expr(11)?;
+                let expr = self.parse_expr(17)?;
                 let span = token.span.join(self.ast.span(expr));
                 Ok(self.ast.push(
                     Expr::Unary {
@@ -216,6 +280,17 @@ impl Parser {
                     span,
                 ))
             }
+            TokenKind::Bang => {
+                let expr = self.parse_expr(17)?;
+                let span = token.span.join(self.ast.span(expr));
+                Ok(self.ast.push(
+                    Expr::Unary {
+                        op: UnaryOp::Not,
+                        expr,
+                    },
+                    span,
+                ))
+            }
             TokenKind::Gt | TokenKind::Gte | TokenKind::Lt | TokenKind::Lte => {
                 let op = match token.kind {
                     TokenKind::Gt => CompareOp::Gt,
@@ -224,7 +299,7 @@ impl Parser {
                     TokenKind::Lte => CompareOp::Lte,
                     _ => unreachable!(),
                 };
-                let value = self.parse_expr(6)?;
+                let value = self.parse_expr(12)?;
                 let span = token.span.join(self.ast.span(value));
                 Ok(self.ast.push(Expr::CompareConstraint { op, value }, span))
             }
@@ -449,10 +524,18 @@ impl Parser {
             TokenKind::Default => Some((InfixKind::Default, 1, 2)),
             TokenKind::SlashSlash => Some((InfixKind::Patch, 3, 4)),
             TokenKind::Amp => Some((InfixKind::And, 5, 6)),
-            TokenKind::Plus => Some((InfixKind::Add, 7, 8)),
-            TokenKind::Minus => Some((InfixKind::Sub, 7, 8)),
-            TokenKind::Star => Some((InfixKind::Mul, 9, 10)),
-            TokenKind::Slash => Some((InfixKind::Div, 9, 10)),
+            TokenKind::PipePipe => Some((InfixKind::LogicalOr, 7, 8)),
+            TokenKind::AmpAmp => Some((InfixKind::LogicalAnd, 9, 10)),
+            TokenKind::EqualEqual => Some((InfixKind::Equal, 11, 12)),
+            TokenKind::BangEqual => Some((InfixKind::NotEqual, 11, 12)),
+            TokenKind::Gt => Some((InfixKind::Greater, 11, 12)),
+            TokenKind::Gte => Some((InfixKind::GreaterEqual, 11, 12)),
+            TokenKind::Lt => Some((InfixKind::Less, 11, 12)),
+            TokenKind::Lte => Some((InfixKind::LessEqual, 11, 12)),
+            TokenKind::Plus => Some((InfixKind::Add, 13, 14)),
+            TokenKind::Minus => Some((InfixKind::Sub, 13, 14)),
+            TokenKind::Star => Some((InfixKind::Mul, 15, 16)),
+            TokenKind::Slash => Some((InfixKind::Div, 15, 16)),
             _ => None,
         }
     }
@@ -549,6 +632,14 @@ enum InfixKind {
     Sub,
     Mul,
     Div,
+    Equal,
+    NotEqual,
+    Greater,
+    GreaterEqual,
+    Less,
+    LessEqual,
+    LogicalAnd,
+    LogicalOr,
     And,
     Patch,
     Default,