litho-diagnostics 1.3.4

Definitions for all diagnostics that Litho (a GraphQL framework) can emit.
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

/// Trait implemented by all different diagnostic types that Litho uses.
pub trait DiagnosticInfo<S> {
    /// Returns the code of this diagnostic. This is usually a letter (e.g. `E`)
    /// followed by 4 digits that represent the error number.
    fn code(&self) -> &'static str;

    /// Returns the message of this diagnostic.
    fn message(&self) -> &'static str;

    /// Returns the primary span that triggered this diagnostic.
    fn span(&self) -> S;

    /// Returns additional labels for this diagnostic: pairs of spans and
    /// explanations.
    fn labels(&self) -> Vec<(S, String)>;

    /// Returns a boolean that indicates if this diagnostic is deprecated.
    /// Deprecated diagnostics are no longer returned but still part of the docs
    /// for historic purposes.
    fn is_deprecated(&self) -> bool;
}

macro_rules! deprecated {
    (@deprecated) => {
        true
    };
    () => {
        false
    };
}

macro_rules! diagnostics {
    ($(
        $code:ident => $name:ident @ $span:ident $(+ $($var:ident),*)? {
            $message:literal,
            $(
                $label:literal @ $label_span:ident
            ),*
        } $(@$directive:ident)?
    ),*) => {
        /// Enum that contains all possible diagnostics that Litho can return.
        #[derive(Clone, Debug)]
        pub enum Diagnostic<S> where S: Copy {
            $(
                #[doc = concat!("(", stringify!($code), ") ", $message)]
                $name($name<S>),
            )*
        }

        impl<S> Diagnostic<S> where S: Copy {
            paste::paste! {
                $(
                    #[doc = concat!("(", stringify!($code), ") ", $message)]
                    pub fn [<$name:snake>](
                        $($($var: String,)*)?
                        $(
                            $label_span: S,
                        )*
                    ) -> Diagnostic<S> {
                        Diagnostic::$name($name {
                            $($($var,)*)?
                            $(
                                $label_span,
                            )*
                        })
                    }
                )*
            }

            /// Returns the code of this diagnostic. This is usually a letter (e.g. `E`)
            /// followed by 4 digits that represent the error number.
            pub fn code(&self) -> &'static str {
                match self {
                    $(Diagnostic::$name(diagnostic) => diagnostic.code(),)*
                }
            }

            /// Returns the message of this diagnostic.
            pub fn message(&self) -> &'static str {
                match self {
                    $(Diagnostic::$name(diagnostic) => diagnostic.message(),)*
                }
            }

            /// Returns the primary span that triggered this diagnostic.
            pub fn span(&self) -> S {
                match self {
                    $(Diagnostic::$name(diagnostic) => diagnostic.span(),)*
                }
            }

            /// Returns additional labels for this diagnostic: pairs of spans and
            /// explanations.
            pub fn labels(&self) -> Vec<(S, String)> {
                match self {
                    $(Diagnostic::$name(diagnostic) => diagnostic.labels(),)*
                }
            }
        }

        $(
            #[allow(rustdoc::bare_urls)]
            #[doc = concat!("(", stringify!($code), ") ", $message)]
            #[derive(Clone, Debug)]
            pub struct $name<S> where S: Copy {
                $($(
                    #[doc = concat!("Value of `{", stringify!($var), "}` that is referenced in the message and/or one of the labels.")]
                    pub $var: String,
                )*)?
                $(
                    #[doc = $label]
                    pub $label_span: S,
                )*
            }

            impl<S> DiagnosticInfo<S> for $name<S> where S: Copy {
                fn code(&self) -> &'static str {
                    stringify!($code)
                }

                fn message(&self) -> &'static str {
                    $message
                }

                fn span(&self) -> S {
                    self.$span
                }

                fn labels(&self) -> Vec<(S, String)> {
                    let $name { $($($var,)*)? $($label_span,)* } = &self;

                    vec![
                        $(
                            (
                                *$label_span,
                                format!($label),
                            ),
                        )*
                    ]
                }

                fn is_deprecated(&self) -> bool {
                    deprecated!($(@$directive)?)
                }
            }
        )*
    };
}