Method parse_expr

src/parser.rs:206–271

(&mut self, precedence: Precedence)

    }

    fn parse_expr(&mut self, precedence: Precedence) -> Option<Expr> {
        let mut left: Option<Expr> = match self.current_token {
            Token::Ident(_) => self.parse_ident(),
            Token::Bang | Token::Minus | Token::Plus => self.parse_prefix_expr(),
            Token::LeftParen => self.parse_grouped_expr(),
            Token::If => self.parse_if_expr(),
            Token::Func => self.parse_fn_expr(),
            Token::Number(_) => self.parse_int_literal(),
            Token::Boolean(_) => self.parse_boolean_literal(),
            Token::String(_) => self.parse_string_literal(),
            Token::LeftBracket => self.parse_array_literal(),
            Token::LeftBrace => self.parse_object_literal(),
            Token::Typeof => self.parse_typof_expr(),
            Token::Loop => self.parse_loop_expr(),
            _ => {
                None
            }
        };

        while !self.peek_token(&Token::Semicolon) && precedence < self.next_token_precedence() {
            match self.peek_token {
                Token::Plus
                | Token::Minus
                | Token::Asterisk
                | Token::Equals
                | Token::Slash
                | Token::Percent
                | Token::NotEquals
                | Token::Less
                | Token::LessEqual
                | Token::Greater
                | Token::GreaterEqual
                | Token::AND
                | Token::OR
                | Token::XOR
                | Token::In => {
                    self.next_token();
                    left = self.parse_infix_expr(left.unwrap());
                }

                Token::LeftShift => {
                    self.lexer.next_token();
                    self.next_token();
                    left = self.parse_infix_expr(left.unwrap());
                }

                Token::RightShift => {
                    self.lexer.next_token();
                    self.next_token();
                    left = self.parse_infix_expr(left.unwrap());
                }

                Token::LeftParen => {
                    self.next_token();
                    left = self.parse_call_expr(left.unwrap());
                }
                Token::LeftBracket => {
                    self.next_token();