target_spec/
errors.rs

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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
// Copyright (c) The cargo-guppy Contributors
// SPDX-License-Identifier: MIT OR Apache-2.0

//! Errors returned by `target-spec`.

use std::{borrow::Cow, error, fmt};

/// An error that happened during `target-spec` parsing or evaluation.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum Error {
    /// A `cfg()` expression was invalid and could not be parsed.
    InvalidExpression(ExpressionParseError),
    /// The provided plain string (in the position that a `cfg()` expression would be) was unknown.
    InvalidTargetSpecString(PlainStringParseError),
    /// The provided platform triple was unknown.
    UnknownPlatformTriple(TripleParseError),
    /// An error occurred while creating a custom triple (in the position that a `cfg()` expression
    /// would be).
    CustomTripleCreate(CustomTripleCreateError),
    /// An error occurred while creating a custom platform.
    CustomPlatformCreate(CustomTripleCreateError),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::InvalidExpression(_) => write!(f, "invalid cfg() expression"),
            Error::InvalidTargetSpecString(_) => {
                write!(f, "failed to parse target spec as a plain string")
            }
            Error::UnknownPlatformTriple(_) => {
                write!(f, "unknown platform triple")
            }
            Error::CustomTripleCreate(_) => write!(f, "error creating custom triple"),
            Error::CustomPlatformCreate(_) => {
                write!(f, "error creating custom platform")
            }
        }
    }
}

impl error::Error for Error {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            Error::InvalidExpression(err) => Some(err),
            Error::InvalidTargetSpecString(err) => Some(err),
            Error::UnknownPlatformTriple(err) => Some(err),
            Error::CustomTripleCreate(err) => Some(err),
            Error::CustomPlatformCreate(err) => Some(err),
        }
    }
}

// Note: ExpressionParseError is a duplicate of cfg_expr::error::ParseError, and is copied here
// because we don't want to expose that in a stable (1.0+) API.

/// An error returned in case a `TargetExpression` cannot be parsed.
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct ExpressionParseError {
    /// The string we tried to parse.
    pub input: String,

    /// The range of characters in the original string that resulted
    /// in this error.
    pub span: std::ops::Range<usize>,

    /// The kind of error that occurred.
    pub kind: ExpressionParseErrorKind,
}

impl ExpressionParseError {
    pub(crate) fn new(input: &str, error: cfg_expr::ParseError) -> Self {
        // The error returned by cfg_expr::ParseError does not include the leading 'cfg('. Use the
        // original input and add 4 which is the length of 'cfg('.
        let span = if input.starts_with("cfg(") && input.ends_with(')') {
            (error.span.start + 4)..(error.span.end + 4)
        } else {
            error.span
        };
        Self {
            input: input.to_owned(),
            span,
            kind: ExpressionParseErrorKind::from_cfg_expr(error.reason),
        }
    }
}

impl fmt::Display for ExpressionParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "error parsing cfg() expression")
    }
}

impl error::Error for ExpressionParseError {}

/// The kind of [`ExpressionParseError`] that occurred.
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum ExpressionParseErrorKind {
    /// not() takes exactly 1 predicate, unlike all() and any()
    InvalidNot(usize),
    /// The characters are not valid in an cfg expression
    InvalidCharacters,
    /// An opening parens was unmatched with a closing parens
    UnclosedParens,
    /// A closing parens was unmatched with an opening parens
    UnopenedParens,
    /// An opening quotes was unmatched with a closing quotes
    UnclosedQuotes,
    /// A closing quotes was unmatched with an opening quotes
    UnopenedQuotes,
    /// The expression does not contain any valid terms
    Empty,
    /// Found an unexpected term, which wasn't one of the expected terms that
    /// is listed
    Unexpected {
        /// The list of expected terms.
        expected: &'static [&'static str],
    },
    /// Failed to parse an integer value
    InvalidInteger,
    /// The root cfg() may only contain a single predicate
    MultipleRootPredicates,
    /// A `target_has_atomic` predicate didn't correctly parse.
    InvalidHasAtomic,
    /// An element was not part of the builtin information in rustc
    UnknownBuiltin,
}

impl ExpressionParseErrorKind {
    fn from_cfg_expr(reason: cfg_expr::error::Reason) -> Self {
        use cfg_expr::error::Reason::*;

        match reason {
            InvalidCharacters => Self::InvalidCharacters,
            UnclosedParens => Self::UnclosedParens,
            UnopenedParens => Self::UnopenedParens,
            UnclosedQuotes => Self::UnclosedQuotes,
            UnopenedQuotes => Self::UnopenedQuotes,
            Empty => Self::Empty,
            Unexpected(expected) => Self::Unexpected { expected },
            InvalidNot(np) => Self::InvalidNot(np),
            InvalidInteger => Self::InvalidInteger,
            MultipleRootPredicates => Self::MultipleRootPredicates,
            InvalidHasAtomic => Self::InvalidHasAtomic,
            UnknownBuiltin => Self::UnknownBuiltin,
        }
    }
}

impl fmt::Display for ExpressionParseErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use ExpressionParseErrorKind::*;

        match self {
            InvalidCharacters => f.write_str("invalid character(s)"),
            UnclosedParens => f.write_str("unclosed parens"),
            UnopenedParens => f.write_str("unopened parens"),
            UnclosedQuotes => f.write_str("unclosed quotes"),
            UnopenedQuotes => f.write_str("unopened quotes"),
            Empty => f.write_str("empty expression"),
            Unexpected { expected } => {
                if expected.len() > 1 {
                    f.write_str("expected one of ")?;

                    for (i, exp) in expected.iter().enumerate() {
                        f.write_fmt(format_args!("{}`{exp}`", if i > 0 { ", " } else { "" }))?;
                    }
                    f.write_str(" here")
                } else if !expected.is_empty() {
                    f.write_fmt(format_args!("expected a `{}` here", expected[0]))
                } else {
                    f.write_str("the term was not expected here")
                }
            }
            InvalidNot(np) => f.write_fmt(format_args!("not() takes 1 predicate, found {np}")),
            InvalidInteger => f.write_str("invalid integer"),
            MultipleRootPredicates => f.write_str("multiple root predicates"),
            InvalidHasAtomic => f.write_str("expected integer or \"ptr\""),
            UnknownBuiltin => f.write_str("unknown built-in"),
        }
    }
}

/// An error that occurred while parsing a [`TargetSpecPlainString`](crate::TargetSpecPlainString).
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct PlainStringParseError {
    /// The input we failed to parse.
    pub input: String,

    /// The character index (in bytes) at which the input failed to parse.
    pub char_index: usize,

    /// The character that failed to parse.
    pub character: char,
}

impl PlainStringParseError {
    pub(crate) fn new(input: String, char_index: usize, character: char) -> Self {
        Self {
            input,
            char_index,
            character,
        }
    }

    /// Returns the range of characters in the input that resulted in this error.
    pub fn span(&self) -> std::ops::Range<usize> {
        let end = self.char_index + self.character.len_utf8();
        self.char_index..end
    }
}

impl fmt::Display for PlainStringParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "failed to parse `{}` at index {}: character \
             must be alphanumeric, `-`, `_` or `.`",
            self.input, self.char_index,
        )
    }
}

impl error::Error for PlainStringParseError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        None
    }
}

/// An error returned while parsing a single target.
///
/// This is produced when both of the following are true:
///
/// 1. The triple is not in the builtin set.
/// 2. If heuristic parsing is enabled, it failed.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TripleParseError {
    triple_str: Cow<'static, str>,
    kind: TripleParseErrorKind,
}

impl TripleParseError {
    pub(crate) fn new(
        triple_str: Cow<'static, str>,
        lexicon_err: cfg_expr::target_lexicon::ParseError,
    ) -> Self {
        Self {
            triple_str,
            kind: TripleParseErrorKind::Lexicon(lexicon_err),
        }
    }

    pub(crate) fn new_strict(triple_str: Cow<'static, str>) -> Self {
        Self {
            triple_str,
            kind: TripleParseErrorKind::LexiconDisabled,
        }
    }

    /// Returns the triple string that could not be parsed.
    pub fn triple_str(&self) -> &str {
        &self.triple_str
    }
}

impl fmt::Display for TripleParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "unknown triple string: {}", self.triple_str)
    }
}

impl error::Error for TripleParseError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        Some(&self.kind)
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
enum TripleParseErrorKind {
    Lexicon(cfg_expr::target_lexicon::ParseError),
    LexiconDisabled,
}

impl fmt::Display for TripleParseErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Lexicon(_) => write!(
                f,
                "triple not in builtin platforms and heuristic parsing failed"
            ),
            Self::LexiconDisabled => write!(
                f,
                "triple not in builtin platforms and heuristic parsing disabled"
            ),
        }
    }
}

impl error::Error for TripleParseErrorKind {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            Self::Lexicon(error) => Some(error),
            Self::LexiconDisabled => None,
        }
    }
}

/// An error returned while creating a custom platform.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum CustomTripleCreateError {
    #[cfg(feature = "custom")]
    /// An error occurred while deserializing serde data.
    Deserialize {
        /// The specified triple.
        triple: String,

        /// The deserialization error that occurred.
        error: std::sync::Arc<serde_json::Error>,
    },

    /// A custom platform was asked to be created, but the `custom` feature is currently disabled.
    ///
    /// Currently, this can only happen if a custom platform is deserialized from a
    /// [`PlatformSummary`](crate::summaries::PlatformSummary),
    Unavailable,
}

impl fmt::Display for CustomTripleCreateError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            #[cfg(feature = "custom")]
            Self::Deserialize { triple, .. } => {
                write!(f, "error deserializing custom target JSON for `{triple}`")
            }
            Self::Unavailable => {
                write!(f, "custom platform currently unavailable")
            }
        }
    }
}

impl error::Error for CustomTripleCreateError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            #[cfg(feature = "custom")]
            Self::Deserialize { error, .. } => Some(error),
            Self::Unavailable => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{TargetSpecExpression, TargetSpecPlainString};
    use test_case::test_case;

    #[test_case("cfg()", 4..4; "empty expression results in span inside cfg")]
    #[test_case("target_os = \"macos", 12..18; "unclosed quote specified without cfg")]
    fn test_expression_parse_error_span(input: &str, expected_span: std::ops::Range<usize>) {
        let err = TargetSpecExpression::new(input).unwrap_err();
        assert_eq!(err.span, expected_span);
    }

    #[test_case("foobar$", 6..7; "dollar sign at end of string")]
    #[test_case("my🛑triple", 2..6; "multibyte character")]
    fn test_plain_string_parse_error_span(input: &str, expected_span: std::ops::Range<usize>) {
        let err = TargetSpecPlainString::new(input.to_owned()).unwrap_err();
        assert_eq!(err.span(), expected_span);
    }
}