Method eat

compiler/src/modules/parser/mod.rs:394–447

Consumes kind or emits diagnostic; for missing closers anchors at opener and drops cascade. */

(&mut self, kind: TokenType)

    /* Consumes kind or emits diagnostic; for missing closers anchors at opener and drops cascade. */
    pub(super) fn eat(&mut self, kind: TokenType) {
        if matches!(self.peek(), Some(k) if k == kind) {
            self.advance();
            return;
        }
        if matches!(kind, TokenType::Rpar | TokenType::Rsqb | TokenType::Rbrace) {
            let peeked = self.tokens.peek().map(|t| t.kind);
            // Wrong closer: bail silently; advance() will report the mismatch.
            if matches!(peeked, Some(TokenType::Rpar | TokenType::Rsqb | TokenType::Rbrace)) && peeked != Some(kind)
            {
                return;
            }
            // Missing closer: anchor diagnostic at the opener, not at the next-line token.
            let want_open = match kind {
                TokenType::Rpar => TokenType::Lpar,
                TokenType::Rsqb => TokenType::Lsqb,
                _ => TokenType::Lbrace,
            };
            if let Some(&(opener_kind, start, end, errors_at_open)) = self.bracket_stack.last()
                && opener_kind == want_open
            {
                self.errors.truncate(errors_at_open);
                self.errors.push(Diagnostic {
                    start, end,
                    msg: s!(str open_str(opener_kind), " was never closed"),
                });
                self.bracket_stack.pop();
                return;
            }
        }
        let label: alloc::string::String = match self.tokens.peek() {
            Some(t) if t.kind == TokenType::Endmarker => "EOF".to_string(),
            Some(t) if t.kind == TokenType::Newline || t.kind == TokenType::Nl => "newline".to_string(),
            Some(t) if t.kind == TokenType::Indent => "indent".to_string(),
            Some(t) if t.kind == TokenType::Dedent => "dedent".to_string(),
            Some(t) if t.start == t.end => t.kind.as_str().to_string(),
            Some(t) => {
                let mut s = alloc::string::String::with_capacity(t.end - t.start + 2);
                s.push('\''); s.push_str(&self.source[t.start..t.end]); s.push('\''); s
            }
            None => "EOF".to_string(),
        };
        let msg = s!("expected ", str kind.as_str(), ", got ", str &label);
        // Token on later line: anchor at end-of-prev-line (common case: missing `:` in header).
        if let Some(t) = self.tokens.peek()
            && t.line > self.last_line
            && self.last_end > 0
        {
            let p = self.last_end;
            self.error_at(p, p, &msg);
        } else {
            self.error(&msg);
        }
    }

    pub(super) fn eat_if(&mut self, kind: TokenType) -> bool {
        if matches!(self.peek(), Some(k) if k == kind) {