Method parse_match_expression

crates/hll-to-ir/src/parser.rs:1961–2002

(&mut self)

        for index in self.pos..self.tokens.len() {
            match self.tokens[index] {
                Token::LBrace => depth += 1,
                Token::RBrace => {
                    depth = depth.saturating_sub(1);
                    if depth == 0 {
                        return self.tokens.get(index + 1) == Some(&Token::ColonEqual);
                    }
                }
                _ => {}
            }
        }
        false
    }

    fn parse_struct_destructure_field(&mut self) -> Result<StructDestructureField, ParserError> {
        let name = self.expect_ident()?;
        self.expect_colon()?;
        let ty = self.parse_type()?;

        Ok(StructDestructureField {
            name: Some(name),
            ty: Some(ty),
        })
    }

    fn expression_to_target(&self, expr: Expression) -> Result<AssignTarget, ParserError> {
        match expr {
            Expression::Primary(PrimaryExpr::Identifier(name)) => {
                Ok(AssignTarget::Identifier(name))
            }
            Expression::Primary(PrimaryExpr::Grouped(expr)) => self.expression_to_target(*expr),
            Expression::Unary {
                op: UnaryOp::Dereference,
                expr,
            } => Ok(AssignTarget::Dereference(expr)),
            Expression::Primary(PrimaryExpr::FieldAccess { expr, field }) => {
                Ok(AssignTarget::FieldAccess {
                    expr: Box::new(self.expression_to_target(*expr)?),
                    field,
                })
            }
            Expression::Primary(PrimaryExpr::ArrayIndex { expr, index }) => {
                Ok(AssignTarget::ArrayIndex {
                    expr: Box::new(self.expression_to_target(*expr)?),
                    index,
                })