mirascript-core 0.1.105

Compiler and bytecode definitions for the MiraScript language
Documentation
use std::{
    fmt::Display,
    ops::{Deref, DerefMut},
};

use super::prelude::*;

#[derive(Debug, Clone)]
pub struct Token<'s> {
    pub kind: TokenKind<'s>,
    pub range: SourceRange,
    pub leading_trivia: TriviaList<'s>,
    pub tailing_trivia: TriviaList<'s>,
}

impl winnow::stream::Location for Token<'_> {
    fn current_token_start(&self) -> usize {
        self.range.start
    }

    fn previous_token_end(&self) -> usize {
        self.range.end
    }
}

impl<'s> Deref for Token<'s> {
    type Target = TokenKind<'s>;

    fn deref(&self) -> &Self::Target {
        &self.kind
    }
}

impl DerefMut for Token<'_> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.kind
    }
}

impl<'s> Token<'s> {
    #[cfg(feature = "formatter")]
    pub(crate) fn full_range(&self) -> SourceRange {
        let start = self
            .leading_trivia
            .first()
            .map_or(self.range.start, |trivia| trivia.range().start);
        let end = self
            .tailing_trivia
            .last()
            .map_or(self.range.end, |trivia| trivia.range().end);
        start..end
    }

    pub(crate) fn new(kind: TokenKind<'s>, range: SourceRange) -> Self {
        Token {
            kind,
            range,
            leading_trivia: Default::default(),
            tailing_trivia: Default::default(),
        }
    }

    pub(crate) fn empty(pos: usize) -> Self {
        Self::new(TokenKind::Empty, pos..pos)
    }
    pub(crate) fn empty_range(range: SourceRange) -> Self {
        Self::new(TokenKind::Empty, range)
    }

    pub(crate) fn unknown<R: Into<TokenKind<'s>>>(
        range: SourceRange,
        recovered: R,
        error: DiagnosticCode,
    ) -> Self {
        Self::new(TokenKind::unknown(recovered, range.clone(), error), range)
    }

    pub(crate) fn unknown_at<R: Into<TokenKind<'s>>>(
        pos: usize,
        recovered: R,
        error: DiagnosticCode,
    ) -> Self {
        Self::unknown(pos..pos, recovered, error)
    }

    pub(crate) fn wrap_as_unknown(&mut self, error: DiagnosticCode) {
        let kind = std::mem::replace(&mut self.kind, TokenKind::Empty);
        self.kind = TokenKind::unknown(kind, self.range.clone(), error);
    }
}

impl PartialEq for Token<'_> {
    fn eq(&self, other: &Self) -> bool {
        self.kind == other.kind
    }
}

impl Display for Token<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.kind.fmt(f)
    }
}