~starkingdoms/starkingdoms

7987ee18b7c038ac37f5c404997bdff18315710e — ghostlyzsh 1 year, 4 months ago 2e454d8 
assignment operators
patch browse .tar.gz 
3 files changed, 199 insertions(+), 384 deletions(-)

M kabel/src/lexer.rs
M kabel/src/macros.rs
M kabel/src/parser.rs

M kabel/src/lexer.rs => kabel/src/lexer.rs +64 -11
@@ 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),


M kabel/src/macros.rs => kabel/src/macros.rs +13 -0
@@ 26,6 26,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) => {
        $crate::error::KabelError::new(


M kabel/src/parser.rs => kabel/src/parser.rs +122 -373
@@ 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<AST, KabelError> {
        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<AST, KabelError> {


@@ 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<AST, KabelError> {


@@ 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)]