// rasm-core/src/parser/mod.rs
//
//! # Парсер RASM
//!
//! ## Что умеет парсить
//!
//! | Паттерн токенов                        | Результат                   |
//! |----------------------------------------|-----------------------------|
//! | `Ident ':'`                            | `Statement::Label`          |
//! | `Mnemonic op1, op2`                    | `Statement::Instruction`    |
//! | `Dot Ident operands...`                | `Statement::Directive`      |
//! | `Newline`                              | пропуск (пустая строка)     |
//!
//! ## Операнды инструкций
//!
//! | Синтаксис                              | `Operand` вариант           |
//! |----------------------------------------|-----------------------------|
//! | `rax`, `xmm0`                          | `Operand::Register`         |
//! | `42`, `0xFF`                           | `Operand::Immediate`        |
//! | `[rax]`, `[rax + rbx*4 + 8]`           | `Operand::Memory`           |
//! | `qword ptr [rax]`                      | `Operand::Memory` + DataType|
//! | `my_label` (в jmp/call/je/...)         | `Operand::Label`            |
//!
//! ## Адресация памяти `[base + index * scale + disp]`
//!
//! Парсер разбирает полную форму SIB-адресации x86_64:
//! - `base`        — любой регистр ([`Registers`])
//! - `index`       — только GPR ([`GPRs`])  
//! - `scale`       — литерал 1, 2, 4 или 8
//! - `displacement` — знаковое 32-битное смещение
//!
//! Примеры: `[rsp]`, `[rbp - 8]`, `[rax + rcx*4]`, `[rip + some_var]`

pub mod ast;
pub mod err;

use crate::{
    isa::{
        DataType, GPRs, Instruction, MemoryAddress, Operand, Registers, Scale,
        directive::{Directive, DirectiveKind, DirectiveOperand},
    },
    lexer::token::{Span, Token, TokenKind},
    str_pool::StrPool,
};

use ast::{AST, BinOp, ConstExpr, Statement};
use err::{ParserError, ParserErrorKind};
use std::str::FromStr;

/// # Парсер
///
/// Хранит состояние второго прохода: срез токенов, текущую позицию курсора,
/// таблицу меток из Pass 1 и накопленные ошибки.
pub struct Parser<'a> {
    /// Все токены, полученные от лексера.
    tokens: &'a [Token],

    /// Текущая позиция в `tokens`. Указывает на токен, который будет обработан следующим.
    cursor: usize,

    /// Пул строк компилятора (нужен для интернирования новых StrId в директивах).
    str_pool: &'a mut StrPool,

    /// Найденные синтаксические ошибки. Парсер не останавливается на первой ошибке —
    /// он фиксирует её и пытается продолжить разбор следующей строки.
    pub errors: Vec<ParserError>,
}

impl<'a> Parser<'a> {
    /// Создаёт парсер и сразу запускает Pass 1 для сбора меток.
    pub fn new(tokens: &'a [Token], str_pool: &'a mut StrPool) -> Self {
        Self {
            tokens,
            cursor: 0,
            str_pool,
            errors: Vec::new(),
        }
    }

    /// Запускает полный разбор токенов и возвращает AST.
    /// При наличии ошибок они будут в `self.errors`, но AST тоже вернётся —
    /// с теми узлами, которые удалось разобрать.
    pub fn parse(&mut self) -> AST {
        let mut ast = AST::new();

        loop {
            // Пропускаем пустые строки между инструкциями
            self.skip_newlines();

            // Конец файла
            if self.peek_kind() == TokenKind::End {
                break;
            }

            // Разбираем одно утверждение
            match self.parse_statement() {
                Some(stmt) => ast.program.push(stmt),
                None => {
                    // Не удалось разобрать — восстанавливаемся: пропускаем до конца строки
                    self.recover_to_next_line();
                }
            }
        }

        ast
    }

    // =========================================================================
    // Разбор утверждений (Statement)
    // =========================================================================

    /// Разбирает одно утверждение: метку, инструкцию или директиву.
    fn parse_statement(&mut self) -> Option<Statement> {
        let tok = self.peek();

        match tok.kind {
            // Метка: Ident ':'
            TokenKind::Ident(name_id) => {
                let span = self.peek().pos;
                // Смотрим вперёд на следующий токен
                if self.peek_next_kind() == TokenKind::Colon {
                    self.advance(); // потребляем Ident
                    self.advance(); // потребляем ':'
                    // После метки обычно идёт \n или следующая инструкция на той же строке
                    self.skip_newlines();
                    return Some(Statement::Label {
                        span,
                        name: name_id,
                    });
                }
                // Ident без ':' — пытаемся распарсить как директиву (db, dw, dd, dq и т.д.)
                let name = self.str_pool.get(name_id).to_string();
                use std::str::FromStr;
                if let Ok(kind) = DirectiveKind::from_str(&name) {
                    self.advance(); // потребляем Ident
                    let operands = self.parse_directive_operands(kind, tok.pos)?;
                    self.expect_end_of_line();
                    return Some(Statement::Directive {
                        span,
                        directive: Directive { kind, operands },
                    });
                }
                // Ident без ':' и не директива — неожиданный токен
                let err_tok = self.advance();
                self.push_error(ParserErrorKind::UnexpectedToken(err_tok.kind), err_tok.pos);
                None
            }

            // Также обрабатываем TokenKind::Type(DataType) как директиву для byte/word/dword/qword
            TokenKind::Type(dt) => {
                let span = self.peek().pos;
                let name = match dt {
                    DataType::Byte => "byte",
                    DataType::Word => "word",
                    DataType::Dword => "dword",
                    DataType::Qword => "qword",
                };
                self.advance(); // потребляем Type
                let kind = DirectiveKind::from_str(name).unwrap();
                let operands = self.parse_directive_operands(kind, tok.pos)?;
                self.expect_end_of_line();
                Some(Statement::Directive {
                    span,
                    directive: Directive { kind, operands },
                })
            }

            // Инструкция: Mnemonic [op1 [, op2 [, op3]]]
            TokenKind::Mnemonic(mnemonic) => {
                let span = self.peek().pos;
                self.advance(); // потребляем мнемонику
                let operands = self.parse_operand_list();
                self.expect_end_of_line();
                Some(Statement::Instruction {
                    span,
                    instruction: Instruction { mnemonic, operands },
                })
            }

            // Директива: '.' Ident [operands...]
            // В нашем лексере '.' — отдельный токен, за ним идёт Ident с именем директивы.
            // Но лексер также выдаёт Ident(".text") целиком для слов типа ".global".
            // Рассмотрим оба варианта.
            TokenKind::Dot => {
                let dot_pos = tok.pos;
                self.advance(); // Пропускаем '.'
                self.parse_directive_after_dot(dot_pos)
            }

            TokenKind::Newline | TokenKind::End => {
                self.advance();
                None
            }

            // Всё остальное — ошибка
            _ => {
                let err_tok = self.advance();
                self.push_error(ParserErrorKind::UnexpectedToken(err_tok.kind), err_tok.pos);
                None
            }
        }
    }

    // =========================================================================
    // Разбор директив
    // =========================================================================

    /// Разбирает директиву, когда '.' уже потреблён.
    fn parse_directive_after_dot(&mut self, dot_pos: Span) -> Option<Statement> {
        // После '.' должен идти Ident с именем директивы
        let name_tok = self.peek();
        let directive_name = match name_tok.kind {
            TokenKind::Ident(id) => {
                let name = self.str_pool.get(id).to_string();
                self.advance();
                name
            }
            _ => {
                self.push_error(
                    ParserErrorKind::UnexpectedToken(name_tok.kind),
                    name_tok.pos,
                );
                return None;
            }
        };

        use std::str::FromStr;
        let kind = match DirectiveKind::from_str(&directive_name) {
            Ok(k) => k,
            Err(_) => {
                // Неизвестная директива — пропускаем строку
                self.push_error(ParserErrorKind::UnexpectedToken(TokenKind::Dot), dot_pos);
                self.recover_to_next_line();
                return None;
            }
        };

        let operands = self.parse_directive_operands(kind, dot_pos)?;
        self.expect_end_of_line();

        Some(Statement::Directive {
            span: dot_pos,
            directive: Directive { kind, operands },
        })
    }

    /// Разбирает операнды директивы в зависимости от её типа.
    fn parse_directive_operands(
        &mut self,
        kind: DirectiveKind,
        pos: Span,
    ) -> Option<Vec<DirectiveOperand>> {
        match kind {
            // Секции — без операндов
            DirectiveKind::Text | DirectiveKind::Data | DirectiveKind::Bss => Some(vec![]),

            // .global / .extern — ожидают имя символа
            DirectiveKind::Global | DirectiveKind::Extern => {
                let tok = self.peek();
                match tok.kind {
                    TokenKind::Ident(id) => {
                        self.advance();
                        Some(vec![DirectiveOperand::Symbol(id)])
                    }
                    _ => {
                        self.push_error(ParserErrorKind::MissingDirectiveOperand, pos);
                        None
                    }
                }
            }

            // .byte / .word / .dword / .quad — числовое значение
            DirectiveKind::Byte
            | DirectiveKind::Word
            | DirectiveKind::Dword
            | DirectiveKind::Qword => {
                let mut operands = vec![];
                loop {
                    let tok = self.peek();
                    match tok.kind {
                        TokenKind::Integer(_)
                        | TokenKind::Minus
                        | TokenKind::Plus
                        | TokenKind::Asterisk => match self.parse_const_expr() {
                            Some(expr) => match expr.evaluate() {
                                Ok(val) => operands.push(DirectiveOperand::Number(val)),
                                Err(ast::ConstExprError::SymbolNotResolved(id)) => {
                                    operands.push(DirectiveOperand::Symbol(id));
                                }
                                Err(ast::ConstExprError::DivisionByZero) => {
                                    self.push_error(
                                        ParserErrorKind::DisplacementOverflow(0),
                                        tok.pos,
                                    );
                                    return None;
                                }
                            },
                            None => break,
                        },
                        TokenKind::Ident(id) => {
                            // Ссылка на символ/метку: .quad my_label
                            self.advance();
                            operands.push(DirectiveOperand::Symbol(id));
                        }
                        _ => break,
                    }
                    // Если следующий токен — запятая, продолжаем список
                    if self.peek_kind() == TokenKind::Comma {
                        self.advance();
                    } else {
                        break;
                    }
                }
                if operands.is_empty() {
                    self.push_error(ParserErrorKind::MissingDirectiveOperand, pos);
                    None
                } else {
                    Some(operands)
                }
            }

            // .ascii / .asciz — строковый литерал: .ascii "Hello, world!\n"
            DirectiveKind::Ascii => {
                let tok = self.peek();
                match tok.kind {
                    TokenKind::StringLiteral(id) => {
                        self.advance();
                        Some(vec![DirectiveOperand::StringLiteral(id)])
                    }
                    _ => {
                        self.push_error(ParserErrorKind::MissingDirectiveOperand, tok.pos);
                        None
                    }
                }
            }

            // .align — числовое значение (степень двойки)
            DirectiveKind::Align => {
                let tok = self.peek();
                if matches!(
                    tok.kind,
                    TokenKind::Integer(_)
                        | TokenKind::Minus
                        | TokenKind::Plus
                        | TokenKind::Asterisk
                ) {
                    match self.parse_const_expr() {
                        Some(expr) => match expr.evaluate() {
                            Ok(val) => Some(vec![DirectiveOperand::Number(val)]),
                            Err(ast::ConstExprError::DivisionByZero) => {
                                self.push_error(ParserErrorKind::DisplacementOverflow(0), tok.pos);
                                None
                            }
                            Err(ast::ConstExprError::SymbolNotResolved(_)) => {
                                self.push_error(ParserErrorKind::MissingDirectiveOperand, pos);
                                None
                            }
                        },
                        None => {
                            self.push_error(ParserErrorKind::MissingDirectiveOperand, pos);
                            None
                        }
                    }
                } else {
                    self.push_error(ParserErrorKind::MissingDirectiveOperand, pos);
                    None
                }
            }
        }
    }

    // =========================================================================
    // Разбор константных выражений
    // =========================================================================

    /// Парсит константное выражение с учётом приоритетов операторов.
    ///
    /// Грамматика (recursive descent):
    /// ```text
    /// expr     ::= term (('+' | '-') term)*
    /// term     ::= factor (('*' | '/') factor)*
    /// factor   ::= Integer | '-' factor | Ident
    /// ```
    fn parse_const_expr(&mut self) -> Option<ConstExpr> {
        self.parse_expr()
    }

    fn parse_expr(&mut self) -> Option<ConstExpr> {
        let mut left = self.parse_term()?;
        loop {
            match self.peek_kind() {
                TokenKind::Plus => {
                    self.advance();
                    let right = self.parse_term()?;
                    left = ConstExpr::BinaryOp {
                        op: BinOp::Add,
                        left: Box::new(left),
                        right: Box::new(right),
                    };
                }
                TokenKind::Minus => {
                    self.advance();
                    let right = self.parse_term()?;
                    left = ConstExpr::BinaryOp {
                        op: BinOp::Sub,
                        left: Box::new(left),
                        right: Box::new(right),
                    };
                }
                _ => break,
            }
        }
        Some(left)
    }

    fn parse_term(&mut self) -> Option<ConstExpr> {
        let mut left = self.parse_factor()?;
        while let TokenKind::Asterisk = self.peek_kind() {
            match self.peek_kind() {
                TokenKind::Asterisk => {
                    self.advance();
                    let right = self.parse_factor()?;
                    left = ConstExpr::BinaryOp {
                        op: BinOp::Mul,
                        left: Box::new(left),
                        right: Box::new(right),
                    };
                }
                _ => break,
            }
        }
        Some(left)
    }

    fn parse_factor(&mut self) -> Option<ConstExpr> {
        let tok = self.peek();
        match tok.kind {
            TokenKind::Integer(n) => {
                self.advance();
                Some(ConstExpr::Immediate(n))
            }
            TokenKind::Minus => {
                self.advance();
                let inner = self.parse_factor()?;
                Some(ConstExpr::BinaryOp {
                    op: BinOp::Sub,
                    left: Box::new(ConstExpr::Immediate(0)),
                    right: Box::new(inner),
                })
            }
            TokenKind::Plus => {
                self.advance();
                self.parse_factor()
            }
            TokenKind::Ident(id) => {
                self.advance();
                Some(ConstExpr::Symbol(id))
            }
            _ => {
                self.push_error(ParserErrorKind::UnexpectedOperand(tok.kind), tok.pos);
                None
            }
        }
    }

    // =========================================================================
    // Разбор операндов инструкций
    // =========================================================================

    /// Разбирает список операндов инструкции: `op1`, `op1, op2`, `op1, op2, op3`
    fn parse_operand_list(&mut self) -> Vec<Operand> {
        let mut operands = vec![];

        // Инструкции без операндов
        if self.is_end_of_line() {
            return operands;
        }

        // Первый операнд
        match self.parse_operand() {
            Some(op) => operands.push(op),
            None => return operands,
        }

        // Второй и третий операнды (через запятую)
        while self.peek_kind() == TokenKind::Comma {
            self.advance(); // потребляем ','
            match self.parse_operand() {
                Some(op) => operands.push(op),
                None => break,
            }
        }

        operands
    }

    /// Разбирает один операнд инструкции.
    ///
    /// `operand_index` — порядковый номер этого операнда (0 = первый, 1 = второй).
    /// Используется для определения, является ли операнд "меткой" (jmp/call всегда
    /// имеют метку как единственный операнд).
    fn parse_operand(&mut self) -> Option<Operand> {
        let tok = self.peek();

        match tok.kind {
            // Регистр
            TokenKind::Register(reg) => {
                self.advance();
                Some(Operand::Register(reg))
            }

            // Непосредственное число или выражение: 42, 1+2*3, -5
            TokenKind::Integer(_) | TokenKind::Minus | TokenKind::Plus | TokenKind::Asterisk => {
                let const_expr = self.parse_const_expr()?;
                match const_expr.evaluate() {
                    Ok(val) => Some(Operand::Immediate(val)),
                    Err(ast::ConstExprError::SymbolNotResolved(id)) => {
                        // Выражение содержит метку — отдаём как Label
                        Some(Operand::Label(id))
                    }
                    Err(ast::ConstExprError::DivisionByZero) => {
                        self.push_error(ParserErrorKind::DisplacementOverflow(0), tok.pos);
                        None
                    }
                }
            }

            // Тип данных: `qword ptr [...]` или просто `qword [...]`
            TokenKind::Type(_data_type) => {
                self.advance(); // потребляем тип
                // Пропускаем необязательное 'ptr' (оно токенизируется как Ident("ptr"))
                if let TokenKind::Ident(id) = self.peek_kind() {
                    let word = self.str_pool.get(id).to_lowercase();
                    if word == "ptr" {
                        self.advance();
                    }
                }
                // После типа обязательно идёт `[`
                if self.peek_kind() == TokenKind::OpeningSquareBracket {
                    self.advance();
                    self.parse_memory_operand(tok.pos)
                } else {
                    self.push_error(ParserErrorKind::UnexpectedToken(self.peek().kind), tok.pos);
                    None
                }
            }

            // Открывающая скобка: `[rax + ...]`
            TokenKind::OpeningSquareBracket => {
                self.advance();
                self.parse_memory_operand(tok.pos)
            }

            // Идентификатор (метка): `jmp my_label`, `call _start`
            TokenKind::Ident(id) => {
                self.advance();
                // Может быть началом constexpr: my_label + 5
                if matches!(
                    self.peek_kind(),
                    TokenKind::Plus | TokenKind::Minus | TokenKind::Asterisk
                ) {
                    let const_expr = self.parse_const_expr()?;
                    match const_expr.evaluate() {
                        Ok(val) => Some(Operand::Immediate(val)),
                        Err(ast::ConstExprError::SymbolNotResolved(_)) => {
                            // Не можем вычислить — пока не поддерживаем label arithmetic
                            self.push_error(
                                ParserErrorKind::UnexpectedOperand(TokenKind::Plus),
                                tok.pos,
                            );
                            None
                        }
                        Err(ast::ConstExprError::DivisionByZero) => {
                            self.push_error(ParserErrorKind::DisplacementOverflow(0), tok.pos);
                            None
                        }
                    }
                } else {
                    Some(Operand::Label(id))
                }
            }

            _ => {
                self.push_error(ParserErrorKind::UnexpectedOperand(tok.kind), tok.pos);
                None
            }
        }
    }

    // =========================================================================
    // Разбор адресации памяти [base + index * scale + displacement]
    // =========================================================================

    /// Разбирает содержимое `[...]`, когда `[` уже потреблён.
    ///
    /// Грамматика (в упрощённой форме):
    /// ```text
    /// mem  ::= '[' expr ']'
    /// expr ::= term ('+' term | '-' term)*
    /// term ::= reg ('*' scale)?
    ///        | integer
    /// ```
    fn parse_memory_operand(&mut self, open_bracket_pos: Span) -> Option<Operand> {
        let mut base: Option<Registers> = None;
        let mut index: Option<GPRs> = None;
        let mut scale: Option<Scale> = None;
        let mut displacement: i32 = 0;
        let mut label = None;

        // Знак для следующего терма: +1 или -1
        let mut sign: i32 = 1;

        loop {
            let tok = self.peek();

            match tok.kind {
                // Конец выражения
                TokenKind::EndingSquareBracket => {
                    self.advance();
                    break;
                }

                // End файла без закрывающей скобки — ошибка
                TokenKind::End | TokenKind::Newline => {
                    self.push_error(ParserErrorKind::UnclosedMemoryBracket, open_bracket_pos);
                    return None;
                }

                // Знаки: '+' и '-'
                TokenKind::Plus => {
                    self.advance();
                    sign = 1;
                    continue;
                }
                TokenKind::Minus => {
                    self.advance();
                    sign = -1;
                    continue;
                }

                // Регистр
                TokenKind::Register(reg) => {
                    self.advance();

                    // Смотрим вперёд: если следующий токен '*' — это index * scale
                    if self.peek_kind() == TokenKind::Asterisk {
                        self.advance(); // потребляем '*'
                        let scale_tok = self.peek();
                        if let TokenKind::Integer(n) = scale_tok.kind {
                            self.advance();
                            let s = match n {
                                1 => Scale::One,
                                2 => Scale::Two,
                                4 => Scale::Four,
                                8 => Scale::Eight,
                                _ => {
                                    self.push_error(
                                        ParserErrorKind::InvalidScale(n),
                                        scale_tok.pos,
                                    );
                                    return None;
                                }
                            };
                            // Индексный регистр должен быть GPR
                            match reg {
                                Registers::GPR(gpr) => {
                                    index = Some(gpr);
                                    scale = Some(s);
                                }
                                _ => {
                                    self.push_error(
                                        ParserErrorKind::UnexpectedOperand(TokenKind::Register(
                                            reg,
                                        )),
                                        tok.pos,
                                    );
                                    return None;
                                }
                            }
                        } else {
                            self.push_error(
                                ParserErrorKind::UnexpectedToken(scale_tok.kind),
                                scale_tok.pos,
                            );
                            return None;
                        }
                    } else {
                        // Это базовый регистр
                        base = Some(reg);
                    }
                }

                // Числовое смещение или выражение
                TokenKind::Integer(_) => {
                    let const_expr = self.parse_const_expr()?;
                    match const_expr.evaluate() {
                        Ok(val) => {
                            let signed = val * (sign as i64);
                            if signed > i32::MAX as i64 || signed < i32::MIN as i64 {
                                self.push_error(
                                    ParserErrorKind::DisplacementOverflow(signed),
                                    tok.pos,
                                );
                                return None;
                            }
                            displacement = displacement.wrapping_add(signed as i32);
                            sign = 1;
                        }
                        Err(ast::ConstExprError::SymbolNotResolved(id)) => {
                            if label.is_some() {
                                self.push_error(
                                    ParserErrorKind::UnexpectedOperand(tok.kind),
                                    tok.pos,
                                );
                                return None;
                            }
                            label = Some(id);
                            sign = 1;
                        }
                        Err(ast::ConstExprError::DivisionByZero) => {
                            self.push_error(ParserErrorKind::DisplacementOverflow(0), tok.pos);
                            return None;
                        }
                    }
                }

                TokenKind::Ident(id) => {
                    self.advance();
                    label = Some(id);
                    sign = 1;
                }

                // Неожиданный токен внутри []
                _ => {
                    self.push_error(ParserErrorKind::UnexpectedToken(tok.kind), tok.pos);
                    return None;
                }
            }
        }

        Some(Operand::Memory(MemoryAddress {
            base,
            index,
            scale,
            displacement,
            label,
        }))
    }

    // =========================================================================
    // Вспомогательные методы навигации по токенам
    // =========================================================================

    /// Возвращает текущий токен без продвижения курсора.
    #[inline]
    fn peek(&self) -> Token {
        // Безопасно: у нас всегда есть минимум токен `End` в конце
        self.tokens[self.cursor.min(self.tokens.len() - 1)]
    }

    /// Возвращает `TokenKind` текущего токена.
    #[inline]
    fn peek_kind(&self) -> TokenKind {
        self.peek().kind
    }

    /// Заглядывает на токен вперёд (cursor + 1), не продвигая курсор.
    #[inline]
    fn peek_next_kind(&self) -> TokenKind {
        let next = (self.cursor + 1).min(self.tokens.len() - 1);
        self.tokens[next].kind
    }

    /// Потребляет текущий токен и возвращает его, продвигая курсор.
    #[inline]
    fn advance(&mut self) -> Token {
        let tok = self.peek();
        if self.cursor < self.tokens.len() - 1 {
            self.cursor += 1;
        }
        tok
    }

    /// Пропускает все токены `Newline`.
    fn skip_newlines(&mut self) {
        while self.peek_kind() == TokenKind::Newline {
            self.advance();
        }
    }

    /// Проверяет, что мы находимся в конце логической строки.
    #[inline]
    fn is_end_of_line(&self) -> bool {
        matches!(self.peek_kind(), TokenKind::Newline | TokenKind::End)
    }

    /// Ожидает конец строки (`Newline` или `End`).
    /// Потребляет `Newline`, если он есть.
    fn expect_end_of_line(&mut self) {
        match self.peek_kind() {
            TokenKind::Newline => {
                self.advance();
            }
            TokenKind::End => {}
            tok => {
                let pos = self.peek().pos;
                self.push_error(
                    ParserErrorKind::ExpectedTokenButFound {
                        expected: TokenKind::Newline,
                        got: tok,
                    },
                    pos,
                );
                self.recover_to_next_line();
            }
        }
    }

    /// Восстановление после ошибки: пропускаем токены до `Newline` или `End`.
    fn recover_to_next_line(&mut self) {
        while !matches!(self.peek_kind(), TokenKind::Newline | TokenKind::End) {
            self.advance();
        }
        if self.peek_kind() == TokenKind::Newline {
            self.advance();
        }
    }

    /// Добавляет ошибку в список.
    fn push_error(&mut self, kind: ParserErrorKind, pos: Span) {
        self.errors.push(ParserError::new(kind, pos));
    }
}
