miette 2.1.0

Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

/*!

Default trait implementations for [Source].
*/
use std::{
    borrow::{Cow, ToOwned},
    fmt::Debug,
    sync::Arc,
};

use crate::{MietteError, MietteSpanContents, Source, SourceSpan, SpanContents};

fn start_line_column(string: &str, span: &SourceSpan) -> Result<(usize, usize), MietteError> {
    let mut offset = 0usize;
    let mut start_line = 0usize;
    let mut start_column = 0usize;
    let mut iter = string.chars().peekable();
    while let Some(char) = iter.next() {
        if offset < span.offset() {
            match char {
                '\r' => {
                    if iter.next_if_eq(&'\n').is_some() {
                        offset += 1;
                    }
                    start_line += 1;
                    start_column = 0;
                }
                '\n' => {
                    start_line += 1;
                    start_column = 0;
                }
                _ => {
                    start_column += 1;
                }
            }
        }

        if offset >= span.offset() + span.len() - 1 {
            return Ok((start_line, start_column));
        }

        offset += char.len_utf8();
    }
    Err(MietteError::OutOfBounds)
}

// The basic impl here is on str (not &str), because otherwise String's impl cannot reuse it
// without creating a temporary &str inside its read_span implementation, and then returning data
// that refers to that temporary.
impl Source for str {
    fn read_span<'a>(
        &'a self,
        span: &SourceSpan,
    ) -> Result<Box<dyn SpanContents + 'a>, MietteError> {
        let (start_line, start_column) = start_line_column(self, span)?;
        return Ok(Box::new(MietteSpanContents::new(
            &self.as_bytes()[span.offset()..span.offset() + span.len()],
            start_line,
            start_column,
        )));
    }
}

/// Makes `src: &'static str` or `struct S<'a> { src: &'a str }` usable.
impl<'s> Source for &'s str {
    fn read_span<'a>(
        &'a self,
        span: &SourceSpan,
    ) -> Result<Box<dyn SpanContents + 'a>, MietteError> {
        <str as Source>::read_span(self, span)
    }
}

impl Source for String {
    fn read_span<'a>(
        &'a self,
        span: &SourceSpan,
    ) -> Result<Box<dyn SpanContents + 'a>, MietteError> {
        <str as Source>::read_span(self, span)
    }
}

impl<T: Source> Source for Arc<T> {
    fn read_span<'a>(
        &'a self,
        span: &SourceSpan,
    ) -> Result<Box<dyn SpanContents + 'a>, MietteError> {
        self.as_ref().read_span(span)
    }
}

impl<T: ?Sized + Source + ToOwned> Source for Cow<'_, T>
where
    // The minimal bounds are used here. `T::Owned` need not be `Source`, because `&T` can always
    // be obtained from `Cow<'_, T>`.
    T::Owned: Debug + Send + Sync,
{
    fn read_span<'a>(
        &'a self,
        span: &SourceSpan,
    ) -> Result<Box<dyn SpanContents + 'a>, MietteError> {
        self.as_ref().read_span(span)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn basic() -> Result<(), MietteError> {
        let src = String::from("foo\n");
        let contents = src.read_span(&(0, 4).into())?;
        assert_eq!("foo\n", std::str::from_utf8(contents.data()).unwrap());
        Ok(())
    }

    #[test]
    fn middle() -> Result<(), MietteError> {
        let src = String::from("foo\nbar\nbaz\n");
        let contents = src.read_span(&(4, 4).into())?;
        assert_eq!("bar\n", std::str::from_utf8(contents.data()).unwrap());
        Ok(())
    }

    #[test]
    fn with_crlf() -> Result<(), MietteError> {
        let src = String::from("foo\r\nbar\r\nbaz\r\n");
        let contents = src.read_span(&(5, 5).into())?;
        assert_eq!("bar\r\n", std::str::from_utf8(contents.data()).unwrap());
        Ok(())
    }
}