trogdor 1.0.0

Error handling for programming languages.
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::io;

use crate::span::Span;

pub struct Diagnostic {
    pub message: Message,
    pub help: Vec<Message>,
}

impl Diagnostic {
    pub fn new(message: impl ToString, span: impl Into<Option<Span>>) -> Self {
        Self {
            message: Message {
                value: message.to_string(),
                span: span.into(),
            },
            help: Vec::new(),
        }
    }

    pub fn help(&mut self, message: impl ToString, span: impl Into<Option<Span>>) -> &mut Self {
        self.help.push(Message {
            value: message.to_string(),
            span: span.into(),
        });
        self
    }

    pub fn write_to(
        &self,
        output: &mut impl io::Write,
        source: &str,
        tag: &str,
        color: &str,
        help_tag: &str,
        help_color: &str,
    ) -> io::Result<()> {
        self.message.write_to(output, source, tag, color)?;
        for msg in &self.help {
            msg.write_to(output, source, help_tag, help_color)?;
        }
        Ok(())
    }
}

pub struct Message {
    pub value: String,
    pub span: Option<Span>,
}

impl Message {
    pub fn write_to(
        &self,
        output: &mut impl io::Write,
        source: &str,
        tag: &str,
        color: &str,
    ) -> io::Result<()> {
        println!("\n{color}{tag}\x1b[0;1m: {}\x1b[22m", self.value);
        if let Some(span) = self.span {
            let lines = source
                .lines()
                .skip(span.start.ln)
                .take(span.end.ln - span.start.ln + 1)
                .enumerate();
            let len = lines.size_hint().1.map(|l| l - 1);
            for (i, line) in lines {
                let first = i == 0;
                let last = Some(i) == len;
                if first && last {
                    write!(
                        output,
                        "\x1b[2m{} |\x1b[22m {}{color}{}\x1b[0m{}",
                        span.start.ln + i + 1,
                        &line[0..span.start.col].replace("\t", "    "),
                        &line[span.start.col..span.end.col].replace("\t", "    "),
                        &line[span.end.col..].replace("\t", "    ")
                    )?;
                } else if first {
                    write!(
                        output,
                        "\x1b[2m{} |\x1b[22m {}{color}{}\x1b[0m",
                        span.start.ln + i + 1,
                        &line[0..span.start.col].replace("\t", "    "),
                        &line[span.start.col..].replace("\t", "    "),
                    )?;
                } else if last {
                    write!(
                        output,
                        "\x1b[2m{} |\x1b[22m {color}{}\x1b[0m{}",
                        span.start.ln + i + 1,
                        &line[0..span.end.col].replace("\t", "    "),
                        &line[span.end.col..].replace("\t", "    "),
                    )?;
                } else {
                    write!(
                        output,
                        "\x1b[2m{} |\x1b[22m \x1b[1;31m{}\x1b[0m",
                        span.start.ln + i + 1,
                        &line.replace("\t", "    "),
                    )?;
                }
            }
        }
        Ok(())
    }
}