Add arithmetic expressions

crates/decodal-core/src/parser.rs

@@ -2,7 +2,7 @@ use alloc::{string::String, vec::Vec};
 
 use crate::{
     SourceId, Span,
-    ast::{Ast, BinaryOp, CompareOp, Expr, ExprId, Field, Literal, MatchArm, Param},
+    ast::{Ast, BinaryOp, CompareOp, Expr, ExprId, Field, Literal, MatchArm, Param, UnaryOp},
     diagnostic::{Diagnostic, Result},
     lexer::{Lexer, Token, TokenKind},
 };
@@ -115,6 +115,38 @@ impl Parser {
             let rhs = self.parse_expr(r_bp)?;
             let span = self.ast.span(lhs).join(self.ast.span(rhs)).join(op_span);
             lhs = match kind {
+                InfixKind::Add => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::Add,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::Sub => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::Sub,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::Mul => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::Mul,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
+                InfixKind::Div => self.ast.push(
+                    Expr::Binary {
+                        op: BinaryOp::Div,
+                        lhs,
+                        rhs,
+                    },
+                    span,
+                ),
                 InfixKind::And => self.ast.push(
                     Expr::Binary {
                         op: BinaryOp::And,
@@ -173,6 +205,17 @@ impl Parser {
             TokenKind::Let => self.parse_let(token.span),
             TokenKind::Match => self.parse_match(token.span),
             TokenKind::Import => self.parse_import(token.span),
+            TokenKind::Minus => {
+                let expr = self.parse_expr(11)?;
+                let span = token.span.join(self.ast.span(expr));
+                Ok(self.ast.push(
+                    Expr::Unary {
+                        op: UnaryOp::Neg,
+                        expr,
+                    },
+                    span,
+                ))
+            }
             TokenKind::Gt | TokenKind::Gte | TokenKind::Lt | TokenKind::Lte => {
                 let op = match token.kind {
                     TokenKind::Gt => CompareOp::Gt,
@@ -181,7 +224,7 @@ impl Parser {
                     TokenKind::Lte => CompareOp::Lte,
                     _ => unreachable!(),
                 };
-                let value = self.parse_expr(8)?;
+                let value = self.parse_expr(6)?;
                 let span = token.span.join(self.ast.span(value));
                 Ok(self.ast.push(Expr::CompareConstraint { op, value }, span))
             }
@@ -406,6 +449,10 @@ 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)),
             _ => None,
         }
     }
@@ -498,6 +545,10 @@ impl Parser {
 
 #[derive(Debug, Clone, Copy)]
 enum InfixKind {
+    Add,
+    Sub,
+    Mul,
+    Div,
     And,
     Patch,
     Default,