[nextest-filtering] Remove use of RefCell

Because parsers now take `&mut I` and all cloning is gone,
we don't need `RefCell` anymore.

nextest-filtering/src/errors.rs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use miette::{Diagnostic, SourceSpan};
-use std::cell::RefCell;
 use thiserror::Error;
 
 /// A set of errors that occurred while parsing a filter expression.
@@ -150,19 +149,19 @@ pub enum GlobConstructError {
     RegexError(String),
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub(crate) struct State<'a> {
     // A `RefCell` is required here because the state must implement `Clone` to work with nom.
-    errors: &'a RefCell<Vec<ParseSingleError>>,
+    errors: &'a mut Vec<ParseSingleError>,
 }
 
 impl<'a> State<'a> {
-    pub fn new(errors: &'a RefCell<Vec<ParseSingleError>>) -> Self {
+    pub fn new(errors: &'a mut Vec<ParseSingleError>) -> Self {
         Self { errors }
     }
 
-    pub fn report_error(&self, error: ParseSingleError) {
-        self.errors.borrow_mut().push(error);
+    pub fn report_error(&mut self, error: ParseSingleError) {
+        self.errors.push(error);
     }
 }
 

nextest-filtering/src/expression.rs

@@ -15,7 +15,7 @@ use guppy::{
 use miette::SourceSpan;
 use nextest_metadata::{RustBinaryId, RustTestBinaryKind};
 use recursion::{Collapsible, CollapsibleExt, MappableFrame, PartiallyApplied};
-use std::{cell::RefCell, collections::HashSet, fmt};
+use std::{collections::HashSet, fmt};
 
 /// Matcher for name
 ///
@@ -227,11 +227,9 @@ impl FilteringSet {
 impl FilteringExpr {
     /// Parse a filtering expression
     pub fn parse(input: String, graph: &PackageGraph) -> Result<Self, FilterExpressionParseErrors> {
-        let errors = RefCell::new(Vec::new());
-        match parse(new_span(&input, &errors)) {
+        let mut errors = Vec::new();
+        match parse(new_span(&input, &mut errors)) {
             Ok(parsed_expr) => {
-                let errors = errors.into_inner();
-
                 if !errors.is_empty() {
                     return Err(FilterExpressionParseErrors::new(input.clone(), errors));
                 }

nextest-filtering/src/parsing.rs

@@ -15,7 +15,7 @@
 
 use guppy::graph::cargo::BuildPlatform;
 use miette::SourceSpan;
-use std::{cell::RefCell, fmt};
+use std::fmt;
 use winnow::{
     ascii::line_ending,
     combinator::{alt, delimited, eof, fold_repeat, peek, preceded, repeat, terminated},
@@ -43,7 +43,7 @@ impl<'a> ToSourceSpan for Span<'a> {
     }
 }
 
-pub(crate) fn new_span<'a>(input: &'a str, errors: &'a RefCell<Vec<ParseSingleError>>) -> Span<'a> {
+pub(crate) fn new_span<'a>(input: &'a str, errors: &'a mut Vec<ParseSingleError>) -> Span<'a> {
     Span {
         input: winnow::Located::new(input),
         state: State::new(errors),
@@ -115,11 +115,11 @@ pub enum ParsedExpr<S = SourceSpan> {
 
 impl ParsedExpr {
     pub fn parse(input: &str) -> Result<Self, Vec<ParseSingleError>> {
-        let errors = RefCell::new(Vec::new());
-        let span = new_span(input, &errors);
+        let mut errors = Vec::new();
+        let span = new_span(input, &mut errors);
         match parse(span).unwrap() {
             ExprResult::Valid(expr) => Ok(expr),
-            ExprResult::Error => Err(errors.into_inner()),
+            ExprResult::Error => Err(errors),
         }
     }
 
@@ -904,12 +904,11 @@ pub(crate) fn parse(input: Span<'_>) -> Result<ExprResult, winnow::error::ErrMod
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::cell::RefCell;
 
     #[track_caller]
     fn parse_regex(input: &str) -> NameMatcher {
-        let errors = RefCell::new(Vec::new());
-        let span = new_span(input, &errors);
+        let mut errors = Vec::new();
+        let span = new_span(input, &mut errors);
         parse_regex_matcher.parse_peek(span).unwrap().1.unwrap()
     }
 
@@ -943,8 +942,8 @@ mod tests {
 
     #[track_caller]
     fn parse_glob(input: &str) -> NameMatcher {
-        let errors = RefCell::new(Vec::new());
-        let span = new_span(input, &errors);
+        let mut errors = Vec::new();
+        let span = new_span(input, &mut errors);
         let matcher = parse_glob_matcher
             .parse_peek(span)
             .unwrap_or_else(|error| {
@@ -957,7 +956,7 @@ mod tests {
                      (reported errors: {errors:?})"
                 )
             });
-        if errors.borrow().len() > 0 {
+        if errors.len() > 0 {
             panic!("for input {input}, parse_glob_matcher reported errors: {errors:?}");
         }
 
@@ -996,8 +995,8 @@ mod tests {
 
     #[track_caller]
     fn parse_set(input: &str) -> SetDef {
-        let errors = RefCell::new(Vec::new());
-        let span = new_span(input, &errors);
+        let mut errors = Vec::new();
+        let span = new_span(input, &mut errors);
         parse_set_def.parse_peek(span).unwrap().1.unwrap()
     }
 
@@ -1425,19 +1424,19 @@ mod tests {
             Ok((n1, n2))
         }
 
-        let errors = RefCell::new(Vec::new());
-        let mut span = new_span("something(aa, bb)", &errors);
+        let mut errors = Vec::new();
+        let mut span = new_span("something(aa, bb)", &mut errors);
         if parse_future_syntax.parse_next(&mut span).is_err() {
             panic!("Failed to parse comma separated matchers");
         }
     }
 
     #[track_caller]
     fn parse_err(input: &str) -> Vec<ParseSingleError> {
-        let errors = RefCell::new(Vec::new());
-        let span = new_span(input, &errors);
+        let mut errors = Vec::new();
+        let span = new_span(input, &mut errors);
         super::parse(span).unwrap();
-        errors.into_inner()
+        errors
     }
 
     macro_rules! assert_error {