From 7987ee18b7c038ac37f5c404997bdff18315710e Mon Sep 17 00:00:00 2001 From: ghostlyzsh Date: Sat, 3 Aug 2024 01:04:18 -0500 Subject: [PATCH] assignment operators --- kabel/src/lexer.rs | 75 ++++++- kabel/src/macros.rs | 13 ++ kabel/src/parser.rs | 495 +++++++++++--------------------------------- 3 files changed, 199 insertions(+), 384 deletions(-) diff --git a/kabel/src/lexer.rs b/kabel/src/lexer.rs index 2e1b3f8caf0e462a2b5533ed1c7c84cc299ab805..0bced9c2958dbfcf743a181db1177bb196c5cef4 100644 --- a/kabel/src/lexer.rs +++ b/kabel/src/lexer.rs @@ -1,5 +1,3 @@ -use std::str::from_utf8; - use crate::{ error::{ErrorKind, KabelError}, token, @@ -36,16 +34,34 @@ impl Lexer { self.read_char(); match self.c { '+' => { - self.output.push(token!(self, TokenType::Plus)); - self.start = self.current; + if self.peek() == '=' { + self.read_char(); + self.output.push(token!(self, TokenType::PlusEqual)); + self.start = self.current; + } else { + self.output.push(token!(self, TokenType::Plus)); + self.start = self.current; + } } '-' => { - self.output.push(token!(self, TokenType::Minus)); - self.start = self.current; + if self.peek() == '=' { + self.read_char(); + self.output.push(token!(self, TokenType::MinusEqual)); + self.start = self.current; + } else { + self.output.push(token!(self, TokenType::Minus)); + self.start = self.current; + } } '*' => { - self.output.push(token!(self, TokenType::Star)); - self.start = self.current; + if self.peek() == '=' { + self.read_char(); + self.output.push(token!(self, TokenType::StarEqual)); + self.start = self.current; + } else { + self.output.push(token!(self, TokenType::Star)); + self.start = self.current; + } } '/' => { if self.peek() == '/' { @@ -53,11 +69,25 @@ impl Lexer { self.read_char(); } self.start = self.current; + } else if self.peek() == '=' { + self.read_char(); + self.output.push(token!(self, TokenType::SlashEqual)); + self.start = self.current; } else { self.output.push(token!(self, TokenType::Slash)); self.start = self.current; } } + '%' => { + if self.peek() == '=' { + self.read_char(); + self.output.push(token!(self, TokenType::PercentEqual)); + self.start = self.current; + } else { + self.output.push(token!(self, TokenType::Percent)); + self.start = self.current; + } + } '(' => { self.output.push(token!(self, TokenType::LeftParen)); self.start = self.current; @@ -95,14 +125,24 @@ impl Lexer { self.start = self.current; } '^' => { - self.output.push(token!(self, TokenType::Caret)); - self.start = self.current; + if self.peek() == '=' { + self.read_char(); + self.output.push(token!(self, TokenType::CaretEqual)); + self.start = self.current; + } else { + self.output.push(token!(self, TokenType::Caret)); + self.start = self.current; + } } '|' => { if self.peek() == '|' { self.read_char(); self.output.push(token!(self, TokenType::OrOr)); self.start = self.current; + } else if self.peek() == '=' { + self.read_char(); + self.output.push(token!(self, TokenType::OrEqual)); + self.start = self.current; } else { self.output.push(token!(self, TokenType::Or)); self.start = self.current; @@ -113,6 +153,10 @@ impl Lexer { self.read_char(); self.output.push(token!(self, TokenType::AndAnd)); self.start = self.current; + } else if self.peek() == '=' { + self.read_char(); + self.output.push(token!(self, TokenType::AndEqual)); + self.start = self.current; } else { self.output.push(token!(self, TokenType::And)); self.start = self.current; @@ -173,8 +217,8 @@ impl Lexer { } contents.push(self.c as char); } - self.start = self.current; self.output.push(token!(self, TokenType::Str(contents))); + self.start = self.current; } '\n' => { self.line += 1; @@ -258,9 +302,15 @@ pub struct Token { #[derive(Debug, Clone, PartialEq)] pub enum TokenType { Star, + StarEqual, Slash, + SlashEqual, + Percent, + PercentEqual, Plus, + PlusEqual, Minus, + MinusEqual, LeftParen, RightParen, LeftBrace, @@ -279,10 +329,13 @@ pub enum TokenType { Less, LessEqual, And, + AndEqual, AndAnd, Or, + OrEqual, OrOr, Caret, + CaretEqual, Ident(String), Str(String), diff --git a/kabel/src/macros.rs b/kabel/src/macros.rs index 3bbb766b7fce56d953b2ea97db640b25d845d2c1..e41d7cf6ee8f095d74b2d12119403ac75ed58bc3 100644 --- a/kabel/src/macros.rs +++ b/kabel/src/macros.rs @@ -25,6 +25,19 @@ macro_rules! lit { }; } +#[macro_export] +macro_rules! ast { + ($ast_type:expr, $start:expr, $end:expr) => { + AST { + ast_type: $ast_type, + start: $start.start, + end: $end.end, + line: $start.line, + column: $start.column, + } + }; +} + #[macro_export] macro_rules! unexpected_token { ($self:expr, $message:expr, $token:expr) => { diff --git a/kabel/src/parser.rs b/kabel/src/parser.rs index 8ab92e99c68a51e589b0d50031b938ae2a0466a4..be6893bdf0cfa1c22bf6372bb8166ca6791ee59c 100644 --- a/kabel/src/parser.rs +++ b/kabel/src/parser.rs @@ -1,7 +1,5 @@ use crate::{ - error::{ErrorKind, KabelError}, - lexer::{Token, TokenType}, - lit, unexpected_token, + ast, error::{ErrorKind, KabelError}, lexer::{Token, TokenType}, lit, unexpected_token }; pub struct Parser { @@ -78,17 +76,8 @@ impl Parser { let right_paren = self.read_token()?; if let TokenType::RightParen = right_paren.token_type { let block = self.block()?; - return Ok(AST { - ast_type: ASTType::Function( - Box::new(lit!(Ident, name, ident)), - expressions, - Box::new(block.clone()), - ), - start: function_ident.start, - end: block.end, - line: function_ident.line, - column: function_ident.column, - }); + return Ok(ast!(ASTType::Function(Box::new(lit!(Ident, name, ident)), + expressions, Box::new(block.clone())), function_ident, block)); } else { return Err(unexpected_token!(self, "Expected ) found {}", right_paren)); } @@ -119,13 +108,7 @@ impl Parser { let expression = self.expression()?; let semicolon = self.read_token()?; if let TokenType::Semicolon = semicolon.token_type { - Ok(AST { - ast_type: ASTType::Return(Some(Box::new(expression))), - start: return_ident.start, - end: semicolon.end, - line: return_ident.line, - column: return_ident.column, - }) + Ok(ast!(ASTType::Return(Some(Box::new(expression))), return_ident, semicolon)) } else { return Err(unexpected_token!(self, "Expected ; found {}", semicolon)); } @@ -134,13 +117,7 @@ impl Parser { pub fn loop_statement(&mut self) -> Result { let loop_ident = self.read_token()?; let block = self.block()?; - Ok(AST { - ast_type: ASTType::Loop(Box::new(block.clone())), - start: loop_ident.start, - end: block.end, - line: loop_ident.line, - column: loop_ident.column, - }) + Ok(ast!(ASTType::Loop(Box::new(block.clone())), loop_ident, block)) } pub fn while_statement(&mut self) -> Result { @@ -151,13 +128,7 @@ impl Parser { let right_paren = self.read_token()?; if let TokenType::RightParen = right_paren.token_type { let block = self.block()?; - return Ok(AST { - ast_type: ASTType::While(Box::new(condition), Box::new(block.clone())), - start: while_ident.start, - end: block.end, - line: while_ident.line, - column: while_ident.column, - }); + return Ok(ast!(ASTType::While(Box::new(condition), Box::new(block.clone())), while_ident, block)); } else { return Err(unexpected_token!(self, "Expected ) found {}", right_paren)); } @@ -195,18 +166,8 @@ impl Parser { let right_paren = self.read_token()?; if let TokenType::RightParen = right_paren.token_type { let block = self.block()?; - return Ok(AST { - ast_type: ASTType::For( - Box::new(expression1), - Box::new(expression2), - Box::new(expression3), - Box::new(block.clone()), - ), - start: for_ident.start, - end: block.end, - line: for_ident.line, - column: for_ident.column, - }); + return Ok(ast!(ASTType::For(Box::new(expression1), Box::new(expression2), + Box::new(expression3), Box::new(block.clone())), for_ident, block)); } else { return Err(unexpected_token!(self, "Expected ) found {}", right_paren)); } @@ -225,13 +186,7 @@ impl Parser { let break_ident = self.read_token()?; let semicolon = self.read_token()?; if let TokenType::Semicolon = semicolon.token_type { - Ok(AST { - ast_type: ASTType::Break, - start: break_ident.start, - end: semicolon.end, - line: break_ident.line, - column: break_ident.column, - }) + Ok(ast!(ASTType::Break, break_ident, semicolon)) } else { Err(unexpected_token!(self, "Expected ; found {}", semicolon)) } @@ -241,13 +196,7 @@ impl Parser { let continue_ident = self.read_token()?; let semicolon = self.read_token()?; if let TokenType::Semicolon = semicolon.token_type { - Ok(AST { - ast_type: ASTType::Continue, - start: continue_ident.start, - end: semicolon.end, - line: continue_ident.line, - column: continue_ident.column, - }) + Ok(ast!(ASTType::Continue, continue_ident, semicolon)) } else { Err(unexpected_token!(self, "Expected ; found {}", semicolon)) } @@ -267,33 +216,15 @@ impl Parser { if content == "else" { if let TokenType::LeftBrace = self.peek()?.token_type { let else_block = self.block()?; - return Ok(AST { - ast_type: ASTType::If( - Box::new(condition), - Box::new(block.clone()), - Some(Box::new(else_block.clone())), - ), - start: if_ident.start, - end: else_block.end, - line: if_ident.line, - column: if_ident.column, - }); + return Ok(ast!(ASTType::If(Box::new(condition), Box::new(block.clone()), + Some(Box::new(else_block.clone()))), if_ident, else_block)); } let else_if_ident = self.peek()?; if let TokenType::Ident(content) = else_if_ident.token_type { if content == "if" { let else_if = self.if_statement()?; - return Ok(AST { - ast_type: ASTType::If( - Box::new(condition), - Box::new(block.clone()), - Some(Box::new(else_if.clone())), - ), - start: if_ident.start, - end: else_if.end, - line: if_ident.line, - column: if_ident.column, - }); + return Ok(ast!(ASTType::If(Box::new(condition), Box::new(block.clone()), + Some(Box::new(else_if.clone()))), if_ident, else_if)); } else { return Err(unexpected_token!( self, @@ -308,13 +239,8 @@ impl Parser { } } } - return Ok(AST { - ast_type: ASTType::If(Box::new(condition), Box::new(block.clone()), None), - start: if_ident.start, - end: block.end, - line: if_ident.line, - column: if_ident.column, - }); + return Ok(ast!(ASTType::If(Box::new(condition), Box::new(block.clone()), + None), if_ident, block)); } else { return Err(unexpected_token!(self, "Expected ) found {}", right_paren)); } @@ -331,13 +257,7 @@ impl Parser { stmts.push(self.statement()?); } let right_brace = self.read_token()?; - return Ok(AST { - ast_type: ASTType::Block(stmts), - start: left_brace.start, - end: right_brace.end, - line: left_brace.line, - column: left_brace.column, - }); + return Ok(ast!(ASTType::Block(stmts), left_brace, right_brace)); } else { return Err(unexpected_token!(self, "Expected {{ found {}", left_brace)); } @@ -381,16 +301,7 @@ impl Parser { let equal = self.read_token()?; if let TokenType::Equal = equal.token_type { let expr = self.expression()?; - return Ok(AST { - ast_type: ASTType::Decl( - Box::new(lit!(Ident, name, ident)), - Box::new(expr.clone()), - ), - start: var.start, - end: expr.end, - line: var.line, - column: var.column, - }); + return Ok(ast!(ASTType::Decl(Box::new(lit!(Ident, name, ident)), Box::new(expr.clone())), var, expr)); } else { return Err(unexpected_token!(self, "Expected = found {}", equal)); } @@ -410,20 +321,52 @@ impl Parser { self.current -= 1; return self.logical_or(); } - if self.peek()?.token_type == TokenType::Equal { - self.read_token()?; + if let TokenType::Equal | TokenType::PlusEqual + | TokenType::MinusEqual | TokenType::StarEqual + | TokenType::SlashEqual | TokenType::PercentEqual + | TokenType::AndEqual | TokenType::CaretEqual + | TokenType::OrEqual = self.peek()?.token_type { + let binop = self.read_token()?; let expr = self.assignment()?; - return Ok(AST { - ast_type: ASTType::Binary( - Box::new(lit!(Ident, name, ident)), - BinOp::Assign, - Box::new(expr.clone()), - ), - start: ident.start, - end: expr.end, - line: ident.line, - column: ident.column, - }); + if binop.token_type == TokenType::Equal { + /*return Ok(AST { + ast_type: ASTType::Binary( + Box::new(lit!(Ident, name, ident)), + BinOp::Asn, + Box::new(expr.clone()), + ), + start: ident.start, + end: expr.end, + line: ident.line, + column: ident.column, + });*/ + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::Asn, Box::new(expr.clone())), ident, expr)); + } else if binop.token_type == TokenType::PlusEqual { + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::AddAsn, Box::new(expr.clone())), ident, expr)); + } else if binop.token_type == TokenType::MinusEqual { + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::SubAsn, Box::new(expr.clone())), ident, expr)); + } else if binop.token_type == TokenType::StarEqual { + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::MulAsn, Box::new(expr.clone())), ident, expr)); + } else if binop.token_type == TokenType::SlashEqual { + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::DivAsn, Box::new(expr.clone())), ident, expr)); + } else if binop.token_type == TokenType::PercentEqual { + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::ModAsn, Box::new(expr.clone())), ident, expr)); + } else if binop.token_type == TokenType::AndEqual { + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::AndAsn, Box::new(expr.clone())), ident, expr)); + } else if binop.token_type == TokenType::CaretEqual { + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::XorAsn, Box::new(expr.clone())), ident, expr)); + } else { + return Ok(ast!(ASTType::Binary(Box::new(lit!(Ident, name, ident)), + BinOp::OrAsn, Box::new(expr.clone())), ident, expr)); + } } self.current -= 1; return self.logical_or(); @@ -438,17 +381,8 @@ impl Parser { while self.current < self.input.len() && self.peek()?.token_type == TokenType::OrOr { self.read_token()?; let right = self.logical_and()?; - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Or, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Or, + Box::new(right.clone())), left, right); } Ok(left) @@ -459,17 +393,8 @@ impl Parser { while self.current < self.input.len() && self.peek()?.token_type == TokenType::AndAnd { self.read_token()?; let right = self.bit_and()?; - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::And, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::And, + Box::new(right.clone())), left, right); } Ok(left) @@ -480,17 +405,8 @@ impl Parser { while self.current < self.input.len() && self.peek()?.token_type == TokenType::And { self.read_token()?; let right = self.bit_xor()?; - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::BitAnd, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::BitAnd, + Box::new(right.clone())), left, right); } Ok(left) @@ -501,17 +417,8 @@ impl Parser { while self.current < self.input.len() && self.peek()?.token_type == TokenType::Caret { self.read_token()?; let right = self.bit_or()?; - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::BitXor, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::BitXor, + Box::new(right.clone())), left, right); } Ok(left) @@ -522,17 +429,8 @@ impl Parser { while self.current < self.input.len() && self.peek()?.token_type == TokenType::Or { self.read_token()?; let right = self.equality()?; - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::BitOr, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::BitOr, + Box::new(right.clone())), left, right); } Ok(left) @@ -547,29 +445,11 @@ impl Parser { let binop = self.read_token()?; let right = self.comparison()?; if binop.token_type == TokenType::EqualEqual { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Eq, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Eq, + Box::new(right.clone())), left, right); } else { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Ne, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Ne, + Box::new(right.clone())), left, right); } } @@ -588,53 +468,17 @@ impl Parser { let binop = self.read_token()?; let right = self.term()?; if binop.token_type == TokenType::Less { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Ls, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Ls, + Box::new(right.clone())), left, right); } else if binop.token_type == TokenType::LessEqual { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Le, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Le, + Box::new(right.clone())), left, right); } else if binop.token_type == TokenType::Greater { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Gr, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Gr, + Box::new(right.clone())), left, right); } else { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Ge, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Ge, + Box::new(right.clone())), left, right); } } @@ -652,29 +496,11 @@ impl Parser { let right = self.factor()?; if binop.token_type == TokenType::Plus { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Add, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Add, + Box::new(right.clone())), left, right); } else { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Sub, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Sub, + Box::new(right.clone())), left, right); } } Ok(left) @@ -684,35 +510,21 @@ impl Parser { while self.current < self.input.len() && (self.peek()?.token_type == TokenType::Star - || self.peek()?.token_type == TokenType::Slash) + || self.peek()?.token_type == TokenType::Slash + || self.peek()?.token_type == TokenType::Percent) { let binop = self.read_token()?; let right = self.unary()?; if binop.token_type == TokenType::Star { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Mul, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Mul, + Box::new(right.clone())), left, right); + } else if binop.token_type == TokenType::Slash { + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Div, + Box::new(right.clone())), left, right); } else { - left = AST { - ast_type: ASTType::Binary( - Box::new(left.clone()), - BinOp::Div, - Box::new(right.clone()), - ), - start: left.start, - end: right.end, - line: left.line, - column: left.column, - }; + left = ast!(ASTType::Binary(Box::new(left.clone()), BinOp::Mod, + Box::new(right.clone())), left, right); } } Ok(left) @@ -722,21 +534,9 @@ impl Parser { let token = self.read_token()?; let unary = self.unary()?; if token.token_type == TokenType::Bang { - return Ok(AST { - ast_type: ASTType::Unary(UnOp::Not, Box::new(unary.clone())), - start: token.start, - end: unary.end, - line: token.line, - column: token.column, - }); + return Ok(ast!(ASTType::Unary(UnOp::Not, Box::new(unary.clone())), token, unary)); } else { - return Ok(AST { - ast_type: ASTType::Unary(UnOp::Neg, Box::new(unary.clone())), - start: token.start, - end: unary.end, - line: token.line, - column: token.column, - }); + return Ok(ast!(ASTType::Unary(UnOp::Neg, Box::new(unary.clone())), token, unary)); } } @@ -750,13 +550,7 @@ impl Parser { let expr = self.expression()?; let right_brace = self.read_token()?; if let TokenType::RightSquare = right_brace.token_type { - primary = AST { - ast_type: ASTType::Subscript(Box::new(primary.clone()), Box::new(expr)), - start: primary.start, - end: right_brace.end, - line: primary.line, - column: primary.column, - }; + primary = ast!(ASTType::Subscript(Box::new(primary.clone()), Box::new(expr)), primary, right_brace); } else { return Err(unexpected_token!(self, "Expected ] found {}", right_brace)); } @@ -777,31 +571,13 @@ impl Parser { return self.member(token); } } - return Ok(AST { - ast_type: ASTType::Lit(Lit::Ident(ident.clone())), - start: token.start, - end: token.end, - line: token.line, - column: token.column, - }); + return Ok(lit!(Ident, ident.clone(), token)); } TokenType::Num(num) => { - return Ok(AST { - ast_type: ASTType::Lit(Lit::Num(num)), - start: token.start, - end: token.end, - line: token.line, - column: token.column, - }); + return Ok(lit!(Num, num, token)); } TokenType::Str(string) => { - return Ok(AST { - ast_type: ASTType::Lit(Lit::Str(string)), - start: token.start, - end: token.end, - line: token.line, - column: token.column, - }); + return Ok(lit!(Str, string, token)); } TokenType::LeftParen => { return self.group(token); @@ -824,13 +600,7 @@ impl Parser { } } let right_square = self.read_token()?; - Ok(AST { - ast_type: ASTType::Lit(Lit::Array(expressions)), - start: left_square.start, - end: right_square.end, - line: left_square.line, - column: left_square.column, - }) + Ok(ast!(ASTType::Lit(Lit::Array(expressions)), left_square, right_square)) } pub fn member(&mut self, ident: Token) -> Result { @@ -843,32 +613,14 @@ impl Parser { if self.current < self.input.len() { if let TokenType::LeftParen = self.peek()?.token_type { let call = self.call(child)?; - expr = AST { - ast_type: ASTType::Member( - Box::new(expr.clone()), - Box::new(call.clone()), - ), - start: expr.start, - end: call.end, - line: expr.line, - column: expr.column, - }; + expr = ast!(ASTType::Member(Box::new(expr.clone()), Box::new(call.clone())), expr, call); if self.current >= self.input.len() { break; } continue; } } - expr = AST { - ast_type: ASTType::Member( - Box::new(expr.clone()), - Box::new(lit!(Ident, child_str, child)), - ), - start: expr.start, - end: child.end, - line: expr.line, - column: expr.column, - }; + expr = ast!(ASTType::Member(Box::new(expr.clone()), Box::new(lit!(Ident, child_str, child))), expr, child); } else { return Err(unexpected_token!(self, "Unexpected token {}", child)); } @@ -892,13 +644,7 @@ impl Parser { } let right_paren = self.read_token()?; if let TokenType::Ident(name) = ident.token_type { - return Ok(AST { - ast_type: ASTType::Call(Box::new(lit!(Ident, name, ident)), expressions), - start: ident.start, - end: right_paren.end, - line: ident.start, - column: ident.column, - }); + return Ok(ast!(ASTType::Call(Box::new(lit!(Ident, name, ident)), expressions), ident, right_paren)); } panic!("Call logic broke"); } @@ -917,13 +663,7 @@ impl Parser { )); } self.read_token()?; - return Ok(AST { - ast_type: ASTType::Group(Box::new(expr.clone())), - start: left_paren.start, - end: right_paren.end, - line: left_paren.line, - column: left_paren.column, - }); + return Ok(ast!(ASTType::Group(Box::new(expr.clone())), left_paren, right_paren)); } if let Err(e) = right_paren { return Err(KabelError::new( @@ -1023,6 +763,19 @@ pub enum BinOp { Sub, Mul, Div, + Mod, + BitAnd, + BitXor, + BitOr, + Asn, + AddAsn, + SubAsn, + MulAsn, + DivAsn, + ModAsn, + AndAsn, + XorAsn, + OrAsn, Eq, Ne, Gr, @@ -1031,10 +784,6 @@ pub enum BinOp { Le, Or, And, - BitAnd, - BitXor, - BitOr, - Assign, } #[derive(Debug, Clone, Copy)]