rantlr-core 0.1.0

Rantlr core: .gr lexer, parser, linter, and in-process runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use std::fmt;

use thiserror::Error;

use crate::diagnostic::{Diagnostic, DiagnosticKind};
use crate::fix_hint::FixHint;
use crate::span::Span;

/// User-facing error for lex / parse / lint failures.
#[derive(Debug, Error, Clone, PartialEq, Eq)]
#[error("{message}")]
pub struct RantlrError {
    pub kind: ErrorKind,
    pub message: String,
    pub line: usize,
    pub column: usize,
    pub snippet: String,
    pub help: Option<String>,
    pub code: Option<String>,
    pub fix_hint: Option<FixHint>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ErrorKind {
    Lex,
    Parse,
    Lint,
}

impl RantlrError {
    pub fn from_diagnostic(source: &str, diag: Diagnostic) -> Self {
        let kind = match diag.kind {
            DiagnosticKind::LexError => ErrorKind::Lex,
            DiagnosticKind::ParseError => ErrorKind::Parse,
            DiagnosticKind::Lint => ErrorKind::Lint,
        };
        let (line, column) = diag.span.line_col(source);
        let snippet = context_snippet(source, diag.span);
        Self {
            kind,
            message: diag.message,
            line,
            column,
            snippet,
            help: diag.help,
            code: diag.code,
            fix_hint: diag.fix,
        }
    }

    pub fn parse(source: &str, message: impl Into<String>, span: Span) -> Self {
        Self::from_diagnostic(
            source,
            Diagnostic::error(DiagnosticKind::ParseError, message, span),
        )
    }

    pub fn parse_with_help(
        source: &str,
        message: impl Into<String>,
        span: Span,
        help: impl Into<String>,
    ) -> Self {
        Self::from_diagnostic(
            source,
            Diagnostic::error(DiagnosticKind::ParseError, message, span).with_help(help),
        )
    }

    pub fn format(&self, file: &str) -> String {
        let mut out = format!(
            "{file}:{}:{}: {:?}: {}\n{}",
            self.line, self.column, self.kind, self.message, self.snippet
        );
        if let Some(help) = &self.help {
            out.push_str("\n  help: ");
            out.push_str(help);
        }
        out
    }
}

impl fmt::Display for ErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Lex => write!(f, "Lex"),
            Self::Parse => write!(f, "Parse"),
            Self::Lint => write!(f, "Lint"),
        }
    }
}

/// Build a small caret snippet around `span`.
pub fn context_snippet(source: &str, span: Span) -> String {
    let (line_no, col) = span.line_col(source);
    let line_text = source
        .lines()
        .nth(line_no.saturating_sub(1))
        .unwrap_or("");

    let gutter = format!("{line_no}");
    let pad = " ".repeat(gutter.len());
    let caret_col = col.saturating_sub(1);
    let caret = format!("{}{}", " ".repeat(caret_col), "^");

    format!("  {gutter} | {line_text}\n  {pad} | {caret}")
}