exprs in pomelo

crates/parser/src/lib.rs

@@ -418,7 +418,6 @@ pomelo! {
     typ ::= F32 { Intern::new(InnerType::Float { float_type: FloatType::F32 }) };
     typ ::= F64 { Intern::new(InnerType::Float { float_type: FloatType::F64 }) };
     typ ::= Bang { Intern::new(InnerType::Bottom) };
-    typ ::= unit { Intern::new(InnerType::Unit) };
     typ ::= Void { Intern::new(InnerType::Unit) };
 
     unit ::= LParen RParen;
@@ -435,9 +434,144 @@ pomelo! {
     %type expr Index;
     %type stmt Index;
     %type stmts Vec<Index>;
-    expr ::= immediate((value, ty)) {
+    expr ::= assignment_expr(expr) { expr };
+
+    assignment_expr ::= or_expr(expr) { expr };
+    assignment_expr ::= or_expr(dest) Equal assignment_expr(expr) {
+        extra.push(AstNode::Assignment { dest, expr })
+    };
+
+    or_expr ::= and_expr(expr) { expr };
+    or_expr ::= or_expr(left) PipePipe and_expr(right) {
+        extra.push(AstNode::LogicalOr { left, right })
+    };
+
+    and_expr ::= bitor_expr(expr) { expr };
+    and_expr ::= and_expr(left) AmpersandAmpersand bitor_expr(right) {
+        extra.push(AstNode::LogicalAnd { left, right })
+    };
+
+    bitor_expr ::= bitxor_expr(expr) { expr };
+    bitor_expr ::= bitor_expr(left) Pipe bitxor_expr(right) {
+        extra.push(AstNode::BitOr { left, right })
+    };
+
+    bitxor_expr ::= bitand_expr(expr) { expr };
+    bitxor_expr ::= bitxor_expr(left) Caret bitand_expr(right) {
+        extra.push(AstNode::BitXor { left, right })
+    };
+
+    bitand_expr ::= equality_expr(expr) { expr };
+    bitand_expr ::= bitand_expr(left) Ampersand equality_expr(right) {
+        extra.push(AstNode::BitAnd { left, right })
+    };
+
+    equality_expr ::= relational_expr(expr) { expr };
+    equality_expr ::= equality_expr(left) EqualEqual relational_expr(right) {
+        extra.push(AstNode::Eq { left, right })
+    };
+    equality_expr ::= equality_expr(left) BangEqual relational_expr(right) {
+        extra.push(AstNode::NotEq { left, right })
+    };
+
+    relational_expr ::= shift_expr(expr) { expr };
+    relational_expr ::= relational_expr(left) Less shift_expr(right) {
+        extra.push(AstNode::Less { left, right })
+    };
+    relational_expr ::= relational_expr(left) LessEqual shift_expr(right) {
+        extra.push(AstNode::LessEq { left, right })
+    };
+    relational_expr ::= relational_expr(left) Greater shift_expr(right) {
+        extra.push(AstNode::Greater { left, right })
+    };
+    relational_expr ::= relational_expr(left) GreaterEqual shift_expr(right) {
+        extra.push(AstNode::GreaterEq { left, right })
+    };
+
+    shift_expr ::= additive_expr(expr) { expr };
+    shift_expr ::= shift_expr(left) LessLess additive_expr(right) {
+        extra.push(AstNode::ShiftLeft { left, right })
+    };
+    shift_expr ::= shift_expr(left) GreaterGreater additive_expr(right) {
+        extra.push(AstNode::ShiftRight { left, right })
+    };
+
+    additive_expr ::= multiplicative_expr(expr) { expr };
+    additive_expr ::= additive_expr(left) Plus multiplicative_expr(right) {
+        extra.push(AstNode::Add { left, right })
+    };
+    additive_expr ::= additive_expr(left) Minus multiplicative_expr(right) {
+        extra.push(AstNode::Subtract { left, right })
+    };
+
+    multiplicative_expr ::= unary_expr(expr) { expr };
+    multiplicative_expr ::= multiplicative_expr(left) Star unary_expr(right) {
+        extra.push(AstNode::Multiply { left, right })
+    };
+    multiplicative_expr ::= multiplicative_expr(left) Slash unary_expr(right) {
+        extra.push(AstNode::Divide { left, right })
+    };
+    multiplicative_expr ::= multiplicative_expr(left) Percent unary_expr(right) {
+        extra.push(AstNode::Modulus { left, right })
+    };
+
+    unary_expr ::= as_expr(expr) { expr };
+    unary_expr ::= Bang unary_expr(expr) {
+        extra.push(AstNode::Not(expr))
+    };
+    unary_expr ::= Minus unary_expr(expr) {
+        extra.push(AstNode::Negate(expr))
+    };
+    unary_expr ::= Star unary_expr(expr) {
+        extra.push(AstNode::Deref { expr })
+    };
+    unary_expr ::= Ampersand unary_expr(expr) {
+        extra.push(AstNode::AddressOf { expr })
+    };
+
+    as_expr ::= postfix_expr(expr) { expr };
+    as_expr ::= postfix_expr(expr) As typ(ty) {
+        extra.push(AstNode::ExplicitCast { expr, ty })
+    };
+
+    postfix_expr ::= primary_expr(expr) { expr };
+    postfix_expr ::= postfix_expr(expr) LBracket expr(index) RBracket {
+        extra.push(AstNode::Subscript { expr, index })
+    };
+    postfix_expr ::= postfix_expr(expr) Dot Ident(field) {
+        extra.push(AstNode::FieldAccess { expr, field: field.to_string() })
+    };
+    postfix_expr ::= postfix_expr(callee) LParen argument_list?(args) RParen {
+        let arguments = args.unwrap_or_default();
+        extra.push(AstNode::CallExpr { callee, arguments })
+    };
+
+    primary_expr ::= LParen expr(expr) RParen { expr };
+    primary_expr ::= Ident(name) {
+        let idx = extra.push(AstNode::UnresolvedDeclRef { name: name.to_string() });
+        idx
+    };
+    primary_expr ::= {
+        let idx = extra.push(AstNode::TypeDeclRef { ty });
+        idx
+    };
+    primary_expr ::= immediate((value, ty)) {
         extra.push(AstNode::Constant { ty, value })
     };
+    primary_expr ::= block(expr) { expr };
+
+    %type argument_list Vec<Index>;
+    argument_list ::= expr(e) {
+        let idx = extra.push(AstNode::Argument { expr: e });
+        vec![idx]
+    };
+    argument_list ::= argument_list(al) Comma expr(e) Comma? {
+        let mut v = al;
+        let idx = extra.push(AstNode::Argument { expr: e });
+        v.push(idx);
+        v
+    };
+
     stmt ::= Semi { extra.push(AstNode::NoopExpr) };
     stmt ::= Comment(text) { extra.push(AstNode::Comment { text: text.to_string() }) };
     stmt ::= expr(expr) Semi { extra.push(AstNode::Stmt { expr }) };
@@ -455,7 +589,6 @@ pomelo! {
     block_inner ::= stmts(ss) {(ss, None)};
     block_inner ::= stmts(ss) expr(expr) {(ss, Some(expr))};
 
-
     block ::= LBrace block_inner((ss, expr)) RBrace {
         extra.push(AstNode::Block {
             statements: ss,