Function parses_struct_destructuring_assignment

crates/hll-to-ir/src/parser.rs:2815–2850

()

        Ok(Pattern::Variant {
            enum_name,
            variant: name,
            bindings,
        })
    }

    // Parse a leading int/char literal pattern (optional `-`), else None so the
    // caller falls through to identifier-led patterns. Char reuses ascii-byte form.
    fn try_parse_literal_pattern(&mut self) -> Result<Option<Literal>, ParserError> {
        match self.peek() {
            Some(Token::Integer(_)) => Ok(Some(Literal::Integer(self.expect_integer()?))),
            Some(Token::HexInteger(_)) => Ok(Some(Literal::HexInteger(self.expect_hex_integer()?))),
            Some(Token::BinInteger(_)) => Ok(Some(Literal::BinInteger(self.expect_bin_integer()?))),
            Some(Token::Char(value)) => {
                let v = *value as i64;
                self.advance();
                Ok(Some(Literal::Integer(v)))
            }
            Some(Token::Minus) => {
                self.advance();
                match self.peek() {
                    Some(Token::Integer(_)) => Ok(Some(Literal::Integer(-self.expect_integer()?))),
                    Some(Token::HexInteger(_)) => {
                        Ok(Some(Literal::HexInteger(-self.expect_hex_integer()?)))
                    }
                    Some(Token::BinInteger(_)) => {
                        Ok(Some(Literal::BinInteger(-self.expect_bin_integer()?)))
                    }
                    _ => Err(self.error("expected integer literal after `-` in match pattern")),
                }
            }
            _ => Ok(None),
        }
    }

    // Canonical field init is `.name = expr` so `:` always introduces a type. A
    // trailing `..` zero-fills the fields the literal leaves unnamed.
    fn parse_struct_literal_fields(&mut self) -> Result<(Vec<FieldInit>, bool), ParserError> {
        self.expect_lbrace()?;
        let mut fields = Vec::new();