eure 0.1.9

Eure core library
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

use eure_tree::{prelude::*, tree::LineNumbers};

use crate::tree::{WriteError, get_error_position_from_error};

pub struct WriteVisitor<'f, 't> {
    input: &'t str,
    line_numbers: LineNumbers<'t>,
    f: &'f mut dyn std::fmt::Write,
}

impl<'f, 't> WriteVisitor<'f, 't> {
    pub fn new(input: &'t str, f: &'f mut dyn std::fmt::Write) -> Self {
        Self {
            input,
            line_numbers: LineNumbers::new(input),
            f,
        }
    }
}

impl<F: CstFacade> CstVisitor<F> for WriteVisitor<'_, '_> {
    type Error = WriteError;

    fn then_construct_error(
        &mut self,
        node_data: Option<CstNode>,
        parent: CstNodeId,
        kind: NodeKind,
        error: CstConstructError,
        tree: &F,
    ) -> Result<(), WriteError> {
        if let Some((line, column)) =
            get_error_position_from_error(&self.line_numbers, &node_data, &error)
        {
            eprintln!("Syntax error at line {line}, column {column}: {error} expected {kind:?}");
        } else {
            eprintln!("Syntax error: {error} expected {kind:?}");
        }
        self.recover_error(node_data, parent, kind, tree)
    }

    fn visit_terminal(
        &mut self,
        _id: CstNodeId,
        _kind: TerminalKind,
        terminal: TerminalData,
        tree: &F,
    ) -> Result<(), WriteError> {
        match terminal {
            TerminalData::Input(input_span) => {
                write!(
                    self.f,
                    "{}",
                    &self.input[input_span.start as usize..input_span.end as usize]
                )?;
            }
            TerminalData::Dynamic(id) => {
                let str = tree
                    .dynamic_token(id)
                    .ok_or(WriteError::DynamicTokenNotFound { id })?;
                write!(self.f, "{str}")?;
            }
        }
        Ok(())
    }
}