rimu-parse 0.2.0

A data structure template system.
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

use chumsky::error::SimpleReason;
use rimu_meta::ErrorReport;

use crate::compiler::CompilerError;
use crate::lexer::lines::LinesLexerError;
use crate::lexer::LexerError;

#[derive(Debug)]
pub enum Error {
    Lexer(LexerError),
    Compiler(CompilerError),
}

impl From<Error> for ErrorReport {
    fn from(value: Error) -> Self {
        match value {
            Error::Lexer(LexerError::Lines(error)) => match error {
                LinesLexerError::InconsistentLeadingWhitespace {
                    span,
                    found,
                    expected,
                } => ErrorReport {
                    message: "Lexer: Inconsistent leading whitespace".into(),
                    span: span.clone(),
                    labels: vec![(
                        span.clone(),
                        format!(
                            "Found {} spaces, expected one of {} spaces.",
                            found,
                            expected
                                .iter()
                                .map(ToString::to_string)
                                .collect::<Vec<String>>()
                                .join(",")
                        ),
                    )],
                    notes: vec![],
                },
            },
            Error::Lexer(LexerError::Line(error)) => ErrorReport {
                message: "Lexer: Unexpected character".into(),
                span: error.span(),
                labels: if let SimpleReason::Custom(msg) = error.reason() {
                    vec![(error.span(), msg.to_string())]
                } else {
                    vec![(error.span(), format!("{}", error))]
                },
                notes: if let Some(e) = error.label() {
                    vec![format!("Label is `{}`", e)]
                } else {
                    vec![]
                },
            },
            Error::Compiler(error) => ErrorReport {
                message: "Compiler: Unexpected token".into(),
                span: error.span(),
                labels: if let SimpleReason::Custom(msg) = error.reason() {
                    vec![(error.span(), msg.to_string())]
                } else {
                    vec![(error.span(), format!("{}", error))]
                },
                notes: if let Some(e) = error.label() {
                    vec![format!("Label is `{}`", e)]
                } else {
                    vec![]
                },
            },
        }
    }
}