nextest_filtering/
errors.rs

1// Copyright (c) The nextest Contributors
2// SPDX-License-Identifier: MIT OR Apache-2.0
3
4// rust nightly 2025-10-12 complains that "value assigned to `kind` is never
5// read", and this is the nearest location this works in. Maybe a miette issue?
6#![allow(unused_assignments)]
7
8use crate::expression::FiltersetKind;
9use miette::{Diagnostic, SourceSpan};
10use std::fmt;
11use thiserror::Error;
12
13/// A set of errors that occurred while parsing a filterset.
14#[derive(Clone, Debug)]
15#[non_exhaustive]
16pub struct FiltersetParseErrors {
17    /// The input string.
18    pub input: String,
19
20    /// The parse errors returned.
21    pub errors: Vec<ParseSingleError>,
22}
23
24impl FiltersetParseErrors {
25    pub(crate) fn new(input: impl Into<String>, errors: Vec<ParseSingleError>) -> Self {
26        Self {
27            input: input.into(),
28            errors,
29        }
30    }
31}
32
33/// An individual error that occurred while parsing a filterset.
34#[derive(Clone, Debug, Error, Diagnostic, PartialEq, Eq)]
35#[non_exhaustive]
36pub enum ParseSingleError {
37    /// An invalid regex was encountered.
38    #[error("invalid regex")]
39    InvalidRegex {
40        /// The part of the input that failed.
41        #[label("{}", message)]
42        span: SourceSpan,
43
44        /// A message indicating the failure.
45        message: String,
46    },
47
48    /// An invalid glob pattern was encountered.
49    #[error("invalid glob")]
50    InvalidGlob {
51        /// The part of the input that failed.
52        #[label("{}", error)]
53        span: SourceSpan,
54
55        /// The underlying error.
56        error: GlobConstructError,
57    },
58
59    /// A banned predicate was encountered.
60    #[error("predicate not allowed in `{kind}` expressions")]
61    BannedPredicate {
62        /// The kind of expression.
63        kind: FiltersetKind,
64
65        /// The span of the banned predicate.
66        #[label("{reason}")]
67        span: SourceSpan,
68
69        /// The reason why the predicate is banned.
70        reason: BannedPredicateReason,
71    },
72
73    /// An invalid regex was encountered but we couldn't determine a better error message.
74    #[error("invalid regex")]
75    InvalidRegexWithoutMessage(#[label("invalid regex")] SourceSpan),
76
77    /// A regex string was not closed.
78    #[error("expected close regex")]
79    ExpectedCloseRegex(#[label("missing `/`")] SourceSpan),
80
81    /// An unexpected OR operator was found.
82    #[error("invalid OR operator")]
83    InvalidOrOperator(#[label("expected `|`, `+`, or `or`")] SourceSpan),
84
85    /// An unexpected AND operator was found.
86    #[error("invalid AND operator")]
87    InvalidAndOperator(#[label("expected `&` or `and`")] SourceSpan),
88
89    /// An unexpected argument was found.
90    #[error("unexpected argument")]
91    UnexpectedArgument(#[label("this set doesn't take an argument")] SourceSpan),
92
93    /// An unexpected comma was found.
94    #[error("unexpected comma")]
95    UnexpectedComma(#[label("this set doesn't take multiple arguments")] SourceSpan),
96
97    /// An invalid string was found.
98    #[error("invalid string")]
99    InvalidString(#[label("invalid string")] SourceSpan),
100
101    /// An open parenthesis `(` was expected but not found.
102    #[error("expected open parenthesis")]
103    ExpectedOpenParenthesis(#[label("missing `(`")] SourceSpan),
104
105    /// A close parenthesis `)` was expected but not found.
106    #[error("expected close parenthesis")]
107    ExpectedCloseParenthesis(#[label("missing `)`")] SourceSpan),
108
109    /// An invalid escape character was found.
110    #[error("invalid escape character")]
111    InvalidEscapeCharacter(#[label("invalid escape character")] SourceSpan),
112
113    /// An expression was expected in this position but not found.
114    #[error("expected expression")]
115    ExpectedExpr(#[label("missing expression")] SourceSpan),
116
117    /// The expression was expected to end here but some extra text was found.
118    #[error("expected end of expression")]
119    ExpectedEndOfExpression(#[label("unparsed input")] SourceSpan),
120
121    /// This matcher didn't match any packages.
122    #[error("operator didn't match any packages")]
123    NoPackageMatch(#[label("no packages matched this")] SourceSpan),
124
125    /// This matcher didn't match any binary IDs.
126    #[error("operator didn't match any binary IDs")]
127    NoBinaryIdMatch(#[label("no binary IDs matched this")] SourceSpan),
128
129    /// This matcher didn't match any binary names.
130    #[error("operator didn't match any binary names")]
131    NoBinaryNameMatch(#[label("no binary names matched this")] SourceSpan),
132
133    /// Expected "host" or "target" for a `platform()` predicate.
134    #[error("invalid argument for platform")]
135    InvalidPlatformArgument(#[label("expected \"target\" or \"host\"")] SourceSpan),
136
137    /// Contained an unsupported expression.
138    #[error("unsupported expression")]
139    UnsupportedExpression(#[label("contained an unsupported expression")] SourceSpan),
140
141    /// An unknown parsing error occurred.
142    #[error("unknown parsing error")]
143    Unknown,
144}
145
146impl ParseSingleError {
147    pub(crate) fn invalid_regex(input: &str, start: usize, end: usize) -> Self {
148        // Use regex-syntax to parse the input so that we get better error messages.
149        match regex_syntax::Parser::new().parse(input) {
150            Ok(_) => {
151                // It is weird that a regex failed to parse with regex but succeeded with
152                // regex-syntax, but we can't do better.
153                Self::InvalidRegexWithoutMessage((start, end - start).into())
154            }
155            Err(err) => {
156                let (message, span) = match &err {
157                    regex_syntax::Error::Parse(err) => (format!("{}", err.kind()), err.span()),
158                    regex_syntax::Error::Translate(err) => (format!("{}", err.kind()), err.span()),
159                    _ => return Self::InvalidRegexWithoutMessage((start, end - start).into()),
160                };
161
162                // This isn't perfect because it doesn't account for "\/", but it'll do for now.
163                let err_start = start + span.start.offset;
164                let err_end = start + span.end.offset;
165
166                Self::InvalidRegex {
167                    span: (err_start, err_end - err_start).into(),
168                    message,
169                }
170            }
171        }
172    }
173}
174
175#[derive(Clone, Debug, Error, PartialEq, Eq)]
176pub enum GlobConstructError {
177    #[error("{}", .0.kind())]
178    InvalidGlob(globset::Error),
179
180    #[error("{}", .0)]
181    RegexError(String),
182}
183
184#[derive(Debug)]
185pub(crate) struct State<'a> {
186    // A `RefCell` is required here because the state must implement `Clone` to work with nom.
187    errors: &'a mut Vec<ParseSingleError>,
188}
189
190impl<'a> State<'a> {
191    pub fn new(errors: &'a mut Vec<ParseSingleError>) -> Self {
192        Self { errors }
193    }
194
195    pub fn report_error(&mut self, error: ParseSingleError) {
196        self.errors.push(error);
197    }
198}
199
200#[derive(Copy, Clone, Debug, PartialEq, Eq)]
201pub enum BannedPredicateReason {
202    /// This predicate causes infinite recursion.
203    InfiniteRecursion,
204    /// This predicate is unsupported.
205    Unsupported,
206}
207
208impl fmt::Display for BannedPredicateReason {
209    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
210        match self {
211            BannedPredicateReason::InfiniteRecursion => {
212                write!(f, "this predicate causes infinite recursion")
213            }
214            BannedPredicateReason::Unsupported => {
215                write!(f, "test() predicates are not supported while archiving")
216            }
217        }
218    }
219}
nextest_filtering/errors.rs

nextest_filtering/
errors.rs
