Method parse_pattern

crates/hll-to-ir/src/parser.rs:2006–2051

A match pattern: `_`, a bare binding (lowercase), or `Variant(b0, b1)` / bare `Variant` (capitalized). `_` discards a payload slot.

(&mut self)

                    index,
                })
            }
            _ => Err(self.error("left side of assignment is not assignable")),
        }
    }

    fn consume_terminators(&mut self) {
        while self.match_statement_terminator() {}
    }

    fn process_string_escapes(&self, input: &str) -> String {
        let mut result = String::with_capacity(input.len());
        let mut chars = input.chars();

        while let Some(c) = chars.next() {
            if c == '\\' {
                match chars.next() {
                    Some('n') => result.push('\n'),
                    Some('t') => result.push('\t'),
                    Some('r') => result.push('\r'),
                    Some('\\') => result.push('\\'),
                    Some('"') => result.push('"'),
                    Some(other) => {
                        result.push('\\');
                        result.push(other);
                    }
                    None => result.push('\\'),
                }
            } else {
                result.push(c);
            }
        }

        result
    }

    // An array length in type position: a literal, or a compile-time constant
    // expression (const decls and associated constants) folded before analysis.
    fn parse_array_length(&mut self) -> Result<ArrayLen, ParserError> {
        if let Some(Token::Integer(text)) = self.peek()
            && matches!(self.peek_n(1), Some(Token::RBracket))
        {
            let value = strip_separators(text)
                .parse::<usize>()
                .map_err(|_| self.error("invalid array size"))?;
            self.advance();
            return Ok(ArrayLen::Fixed(value));
        }
        match self.peek() {
            Some(Token::RBracket) | None => Err(self.error("expected array size")),