errore 0.4.1

Library for error handling and tracing
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

#![allow(clippy::iter_cloned_collect, clippy::uninlined_format_args)]

use errore::prelude::*;

fn assert<T: std::fmt::Display>(expected: &str, value: T) {
    assert_eq!(expected, value.to_string());
}

#[test]
fn test_rcc() {
    // Some of the elaborate cases from the rcc codebase, which is a C compiler in
    // Rust. https://github.com/jyn514/rcc/blob/0.8.0/src/data/error.rs
    #[derive(Error, Debug)]
    pub enum CompilerError {
        #[error("cannot shift {} by {maximum} or more bits (got {current})", if *.is_left { "left" } else { "right" })]
        TooManyShiftBits {
            is_left: bool,
            maximum: u64,
            current: u64,
        },

        #[error("#error {}", (.0).iter().copied().collect::<Vec<_>>().join(" "))]
        User(Vec<&'static str>),

        #[error("overflow while parsing {}integer literal",
        if let Some(signed) = .is_signed {
            if *signed { "signed "} else { "unsigned "}
        } else {
            ""
        }
    )]
        IntegerOverflow { is_signed: Option<bool> },

        #[error("overflow while parsing {}integer literal", match .is_signed {
        Some(true) => "signed ",
        Some(false) => "unsigned ",
        None => "",
    })]
        IntegerOverflow2 { is_signed: Option<bool> },
    }

    assert(
        "cannot shift left by 32 or more bits (got 50)",
        CompilerError::TooManyShiftBits {
            is_left: true,
            maximum: 32,
            current: 50,
        },
    );

    assert("#error A B C", CompilerError::User(vec!["A", "B", "C"]));

    assert(
        "overflow while parsing signed integer literal",
        CompilerError::IntegerOverflow {
            is_signed: Some(true),
        },
    );
}

#[test]
fn test_rustup() {
    // Examples drawn from Rustup.
    #[derive(Error, Debug)]
    pub enum RustupError {
        #[error(
        "toolchain '{name}' does not contain component {component}{}",
        .suggestion
            .as_ref()
            .map_or_else(String::new, |s| format!("; did you mean '{}'?", s)),
    )]
        UnknownComponent {
            name: String,
            component: String,
            suggestion: Option<String>,
        },
    }

    assert(
        "toolchain 'nightly' does not contain component clipy; did you mean 'clippy'?",
        RustupError::UnknownComponent {
            name: "nightly".to_owned(),
            component: "clipy".to_owned(),
            suggestion: Some("clippy".to_owned()),
        },
    );
}