error-enum 1.0.0-alpha.6

Provide a easy way to define an enum that represents errors with error codes, document comments and several other functionalities.
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

//! An example.
#![allow(clippy::unwrap_used)]
#![no_std]

extern crate alloc;
extern crate std as _std;

use _std::eprintln;
use alloc::{
    borrow::ToOwned as _,
    string::{String, ToString as _},
};
use error_enum::{error_type, ErrorType, ErrorTypeExt, SimpleSpan};

error_type! {
    /// Defined error type, will be generated as an `enum`.
    #[derive(Debug)]
    pub MyError {
        // You can use a `#[diag(kind = "...")]` to set the error kind of the subtree.
        #[diag(kind = "Warn")]
        {
            // You can use `#[diag(number = "...")]` to specify a number (prefix) to the subtree.
            #[diag(number = "0")]
            // You can use `#[diag(msg = "...")]` to specify the error message of the variant.
            #[diag(msg = "The token `{0}` is not formatted well.")]
            #[diag(label = "consider reformatting the token")]
            MalformedToken(
                String,
                #[diag(span)]
                SimpleSpan,
            )
        },
        #[diag(kind = "Error")]
        {
            #[diag(number = "0")]
            {
                // Nested `#[diag(number = ...)]` will be concatenated,
                // so this error will have an error number "00".
                #[diag(number = "0")]
                #[diag(msg = "`{term}` is expected to be of type `{expected_ty}`, but is of type `{actual_ty}`.")]
                #[diag(label = "the problematic term is here")]
                TypeError {
                    /// The term.
                    term: String,
                    /// Expected type.
                    expected_ty: String,
                    /// Actual type.
                    actual_ty: String,
                    /// Span of the term.
                    #[diag(span)]
                    span: SimpleSpan,
                }
            }
        },
    }
}

fn main() {
    let span = SimpleSpan::new(
        "file://test.py",
        "print(1 + 2)\nprint(1 + '1')\nprint('1' + '1')",
        23,
        26,
    );
    let error = MyError::TypeError {
        term: "'1'".to_owned(),
        expected_ty: "int".to_owned(),
        actual_ty: "str".to_owned(),
        span: span.clone(),
    };

    assert_eq!(
        error.to_string(),
        "`'1'` is expected to be of type `int`, but is of type `str`."
    );
    assert_eq!(error.code(), "E00");
    assert_eq!(error.primary_span(), Some(span));

    eprintln!("---------- display ----------\n{}", error);

    #[cfg(feature = "annotate-snippets")]
    eprintln!(
        "---------- annotate-snippets ----------\n{}",
        error.fmt_as_annotate_snippets_with_opts(annotate_snippets::display_list::FormatOptions {
            color: true,
            anonymized_line_numbers: false,
            margin: None,
        })
    );

    #[cfg(feature = "ariadne")]
    eprintln!(
        "---------- ariadne ----------\n{}",
        error.fmt_as_ariadne_report().unwrap()
    );

    #[cfg(feature = "codespan-reporting")]
    eprintln!(
        "---------- codespan-reporting ----------\n{}",
        error
            .fmt_as_codespan_diagnostic_with(
                codespan_reporting::term::Config::default(),
                Some(&codespan_reporting::term::Styles::default())
            )
            .unwrap()
    );

    #[cfg(feature = "miette")]
    eprintln!(
        "---------- miette (Narratable) ----------\n{}",
        error.fmt_as_miette_diagnostic_with(&miette::NarratableReportHandler::new())
    );
    #[cfg(feature = "miette")]
    eprintln!(
        "---------- miette (JSON) ----------\n{}",
        error.fmt_as_miette_diagnostic_with(&miette::JSONReportHandler::new())
    );
    #[cfg(feature = "miette")]
    eprintln!(
        "---------- miette (ASCII Graphical) ----------\n{}",
        error.fmt_as_miette_diagnostic_with(&miette::GraphicalReportHandler::new_themed(
            miette::GraphicalTheme::ascii()
        ))
    );
    #[cfg(feature = "miette")]
    eprintln!(
        "---------- miette (Unicode Graphical) ----------\n{}",
        error.fmt_as_miette_diagnostic_with(&miette::GraphicalReportHandler::new_themed(
            miette::GraphicalTheme::unicode()
        ))
    );
}