Method parse_postfix

crates/hll-to-ir/src/parser.rs:1017–1124

(&mut self, mut expr: Expression)

                left: Box::new(expr),
                right: Box::new(right),
            };
        }
        Ok(expr)
    }

    fn parse_bitwise_xor(&mut self) -> Result<Expression, ParserError> {
        let mut expr = self.parse_bitwise_and()?;
        while self.match_bitwise_xor() {
            self.consume_terminators();
            let right = self.parse_bitwise_and()?;
            expr = Expression::Binary {
                op: BinaryOp::BitwiseXor,
                left: Box::new(expr),
                right: Box::new(right),
            };
        }
        Ok(expr)
    }

    fn parse_bitwise_and(&mut self) -> Result<Expression, ParserError> {
        let mut expr = self.parse_shift()?;
        while self.match_bitwise_and() {
            self.consume_terminators();
            let right = self.parse_shift()?;
            expr = Expression::Binary {
                op: BinaryOp::BitwiseAnd,
                left: Box::new(expr),
                right: Box::new(right),
            };
        }
        Ok(expr)
    }

    fn parse_equality(&mut self) -> Result<Expression, ParserError> {
        let mut expr = self.parse_comparison()?;
        loop {
            self.consume_terminators();
            let op = if self.match_eq() {
                Some(BinaryOp::Eq)
            } else if self.match_neq() {
                Some(BinaryOp::Neq)
            } else {
                None
            };

            let Some(op) = op else { break };
            self.consume_terminators();
            let right = self.parse_comparison()?;
            expr = Expression::Binary {
                op,
                left: Box::new(expr),
                right: Box::new(right),
            };
        }
        Ok(expr)
    }

    fn parse_comparison(&mut self) -> Result<Expression, ParserError> {