rich-err 0.1.0

A highly detailed error type for compilers, tracebacks, etc.
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

//! [Note]s provide a clean and easy way to make error messages more useful to the user.

use crate::span::Span;
use ariadne::ReportBuilder;

/// Specifies a [note](Note)'s kind.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum NoteKind {
    /// An ordinary note.
    ///
    /// These are useful for statements that add context to an error.
    #[default]
    Note,
    /// A note designed to assist the user.
    ///
    /// These are useful for suggestions that would help the user address the error.
    Help,
}

/// A message meant to provide extra context and/or assistance within an error message.
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct Note {
    /// What kind of note this is.
    ///
    /// This is used to customize the error reporting when [`Note::add_to`] is inevitably called.
    pub kind: NoteKind,
    /// The note's contents.
    pub message: String,
}

impl Note {
    /// Creates a new note with the given message.
    ///
    /// # Examples
    ///
    /// ```
    /// # use rich_err::note::{Note, NoteKind};
    /// assert_eq!(
    ///     Note::new_note("foo"),
    ///     Note {
    ///         kind: NoteKind::Note,
    ///         message: "foo".to_string(),
    ///     },
    /// );
    /// ```
    pub fn new_note<S>(message: S) -> Self
    where
        S: ToString,
    {
        Self {
            kind: NoteKind::Note,
            message: message.to_string(),
        }
    }

    /// Creates a new note with the given help message.
    ///
    /// # Examples
    ///
    /// ```
    /// # use rich_err::note::{Note, NoteKind};
    /// assert_eq!(
    ///     Note::new_help("foo"),
    ///     Note {
    ///         kind: NoteKind::Help,
    ///         message: "foo".to_string(),
    ///     },
    /// );
    /// ```
    pub fn new_help<S>(message: S) -> Self
    where
        S: ToString,
    {
        Self {
            kind: NoteKind::Help,
            message: message.to_string(),
        }
    }

    /// Adds this note to a [`ReportBuilder`].
    pub fn add_to<Source>(self, builder: &mut ReportBuilder<'_, (Source, Span)>)
    where
        (Source, Span): ariadne::Span,
    {
        match self.kind {
            NoteKind::Note => builder.add_note(self.message),
            NoteKind::Help => builder.add_help(self.message),
        }
    }
}