Tune lints for 1.80 Rust

.clippy.toml

@@ -13,6 +13,8 @@ absolute-paths-allowed-crates = [
 
 doc-valid-idents = ["JUnit"]
 
+ignore-interior-mutability = ["cucumber::step::HashableRegex"]
+
 standard-macro-braces = [
     { name = "assert", brace = "(" },
     { name = "assert_eq", brace = "(" },

codegen/src/lib.rs

@@ -93,6 +93,7 @@
     clippy::read_zero_byte_vec,
     clippy::redundant_clone,
     clippy::redundant_type_annotations,
+    clippy::renamed_function_params,
     clippy::ref_patterns,
     clippy::rest_pat_in_fully_bound_structs,
     clippy::same_name_method,
@@ -130,6 +131,7 @@
     clippy::use_self,
     clippy::useless_let_if_seq,
     clippy::verbose_file_reads,
+    clippy::while_float,
     clippy::wildcard_enum_match_arm,
     explicit_outlives_requirements,
     future_incompatible,

src/cucumber.rs

@@ -572,8 +572,8 @@ where
     /// [`cli::Opts`].
     ///
     /// > ⚠️ __WARNING__: Any CLI options of [`Parser`], [`Runner`], [`Writer`]
-    ///                   or custom ones should not overlap, otherwise
-    ///                   [`cli::Opts`] will fail to parse on startup.
+    /// >                 or custom ones should not overlap, otherwise
+    /// >                 [`cli::Opts`] will fail to parse on startup.
     ///
     /// # Example
     ///

src/lib.rs

@@ -94,6 +94,7 @@
     clippy::read_zero_byte_vec,
     clippy::redundant_clone,
     clippy::redundant_type_annotations,
+    clippy::renamed_function_params,
     clippy::ref_patterns,
     clippy::rest_pat_in_fully_bound_structs,
     clippy::same_name_method,
@@ -131,6 +132,7 @@
     clippy::use_self,
     clippy::useless_let_if_seq,
     clippy::verbose_file_reads,
+    clippy::while_float,
     clippy::wildcard_enum_match_arm,
     explicit_outlives_requirements,
     future_incompatible,

src/parser/basic.rs

@@ -61,7 +61,7 @@ impl<I: AsRef<Path>> Parser<I> for Basic {
     type Output =
         stream::Iter<vec::IntoIter<Result<gherkin::Feature, ParseError>>>;
 
-    fn parse(self, path: I, cli: Self::Cli) -> Self::Output {
+    fn parse(self, input: I, cli: Self::Cli) -> Self::Output {
         let walk = |walker: GlobWalker| {
             walker
                 .filter_map(Result::ok)
@@ -78,7 +78,7 @@ impl<I: AsRef<Path>> Parser<I> for Basic {
         };
 
         let get_features_path = || {
-            let path = path.as_ref();
+            let path = input.as_ref();
             path.canonicalize()
                 .or_else(|_| {
                     let mut buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));

src/tracing.rs

@@ -403,13 +403,13 @@ where
 {
     fn on_new_span(
         &self,
-        attr: &span::Attributes<'_>,
+        attrs: &span::Attributes<'_>,
         id: &span::Id,
         ctx: layer::Context<'_, S>,
     ) {
         if let Some(span) = ctx.span(id) {
             let mut visitor = GetScenarioId(None);
-            attr.values().record(&mut visitor);
+            attrs.values().record(&mut visitor);
 
             if let Some(scenario_id) = visitor.0 {
                 let mut ext = span.extensions_mut();

src/writer/basic.rs

@@ -140,14 +140,14 @@ where
 
     async fn handle_event(
         &mut self,
-        ev: parser::Result<Event<event::Cucumber<W>>>,
-        opts: &Self::Cli,
+        event: parser::Result<Event<event::Cucumber<W>>>,
+        cli: &Self::Cli,
     ) {
         use event::{Cucumber, Feature};
 
-        self.apply_cli(*opts);
+        self.apply_cli(*cli);
 
-        match ev.map(Event::into_inner) {
+        match event.map(Event::into_inner) {
             Err(err) => self.parsing_failed(&err),
             Ok(
                 Cucumber::Started
@@ -263,7 +263,7 @@ impl<Out: io::Write> Basic<Out> {
         error: impl Display,
     ) -> io::Result<()> {
         self.output
-            .write_line(&self.styles.err(format!("Failed to parse: {error}")))
+            .write_line(self.styles.err(format!("Failed to parse: {error}")))
     }
 
     /// Outputs the [started] [`Feature`].
@@ -275,7 +275,7 @@ impl<Out: io::Write> Basic<Out> {
         feature: &gherkin::Feature,
     ) -> io::Result<()> {
         let out = format!("{}: {}", feature.keyword, feature.name);
-        self.output.write_line(&self.styles.ok(out))
+        self.output.write_line(self.styles.ok(out))
     }
 
     /// Outputs the [`Rule`]'s [started]/[scenario]/[finished] event.
@@ -321,7 +321,7 @@ impl<Out: io::Write> Basic<Out> {
             indent = " ".repeat(self.indent)
         );
         self.indent += 2;
-        self.output.write_line(&self.styles.ok(out))
+        self.output.write_line(self.styles.ok(out))
     }
 
     /// Outputs the [`Scenario`]'s [started]/[background]/[step] event.
@@ -404,7 +404,7 @@ impl<Out: io::Write> Basic<Out> {
             }
         };
 
-        self.output.write_line(&style(format!(
+        self.output.write_line(style(format!(
             "{indent}✘  Scenario's {which} hook failed {}:{}:{}\n\
              {indent}   Captured output: {}{}",
             feat.path
@@ -448,15 +448,15 @@ impl<Out: io::Write> Basic<Out> {
                 retries.current,
                 retries.left + retries.current,
             );
-            self.output.write_line(&self.styles.retry(out))
+            self.output.write_line(self.styles.retry(out))
         } else {
             let out = format!(
                 "{}{}: {}",
                 " ".repeat(self.indent),
                 scenario.keyword,
                 scenario.name,
             );
-            self.output.write_line(&self.styles.ok(out))
+            self.output.write_line(self.styles.ok(out))
         }
     }
 
@@ -598,7 +598,7 @@ impl<Out: io::Write> Basic<Out> {
                 .unwrap_or_default(),
         );
 
-        self.output.write_line(&style(format!(
+        self.output.write_line(style(format!(
             "{indent}{step_keyword}{step_value}{doc_str}{step_table}",
             indent = " ".repeat(self.indent.saturating_sub(3)),
         )))
@@ -614,7 +614,7 @@ impl<Out: io::Write> Basic<Out> {
         step: &gherkin::Step,
     ) -> io::Result<()> {
         self.clear_last_lines_if_term_present()?;
-        self.output.write_line(&self.styles.skipped(format!(
+        self.output.write_line(self.styles.skipped(format!(
             "{indent}?  {}{}{}{}\n\
              {indent}   Step skipped: {}:{}:{}",
             step.keyword,
@@ -877,7 +877,7 @@ impl<Out: io::Write> Basic<Out> {
                 .unwrap_or_default(),
         );
 
-        self.output.write_line(&style(format!(
+        self.output.write_line(style(format!(
             "{step_keyword}{step_value}{doc_str}{step_table}",
         )))
     }
@@ -893,7 +893,7 @@ impl<Out: io::Write> Basic<Out> {
         step: &gherkin::Step,
     ) -> io::Result<()> {
         self.clear_last_lines_if_term_present()?;
-        self.output.write_line(&self.styles.skipped(format!(
+        self.output.write_line(self.styles.skipped(format!(
             "{indent}?> {}{}{}{}\n\
              {indent}   Background step failed: {}:{}:{}",
             step.keyword,

src/writer/discard.rs

@@ -29,10 +29,10 @@ impl<W: World, Wr: Writer<W> + ?Sized> Writer<W> for Arbitrary<Wr> {
 
     async fn handle_event(
         &mut self,
-        ev: parser::Result<Event<Cucumber<W>>>,
+        event: parser::Result<Event<Cucumber<W>>>,
         cli: &Self::Cli,
     ) {
-        self.0.handle_event(ev, cli).await;
+        self.0.handle_event(event, cli).await;
     }
 }
 
@@ -114,10 +114,10 @@ impl<W: World, Wr: Writer<W> + ?Sized> Writer<W> for Stats<Wr> {
 
     async fn handle_event(
         &mut self,
-        ev: parser::Result<Event<Cucumber<W>>>,
+        event: parser::Result<Event<Cucumber<W>>>,
         cli: &Self::Cli,
     ) {
-        self.0.handle_event(ev, cli).await;
+        self.0.handle_event(event, cli).await;
     }
 }
 

src/writer/json.rs

@@ -799,18 +799,18 @@ impl Feature {
 }
 
 impl PartialEq<gherkin::Feature> for Feature {
-    fn eq(&self, feature: &gherkin::Feature) -> bool {
+    fn eq(&self, other: &gherkin::Feature) -> bool {
         self.uri
             .as_ref()
             .and_then(|uri| {
-                feature
+                other
                     .path
                     .as_ref()
                     .and_then(|p| p.to_str().map(trim_path))
                     .map(|path| uri == path)
             })
             .unwrap_or_default()
-            && self.name == feature.name
+            && self.name == other.name
     }
 }
 

src/writer/junit.rs

@@ -112,14 +112,14 @@ where
 
     async fn handle_event(
         &mut self,
-        ev: parser::Result<Event<event::Cucumber<W>>>,
-        opts: &Self::Cli,
+        event: parser::Result<Event<event::Cucumber<W>>>,
+        cli: &Self::Cli,
     ) {
         use event::{Cucumber, Feature, Rule};
 
-        self.apply_cli(*opts);
+        self.apply_cli(*cli);
 
-        match ev.map(Event::split) {
+        match event.map(Event::split) {
             Err(err) => self.handle_error(&err),
             Ok((Cucumber::Started | Cucumber::ParsingFinished { .. }, _)) => {}
             Ok((Cucumber::Feature(feat, ev), meta)) => match ev {

src/writer/mod.rs

@@ -86,7 +86,7 @@ pub trait Writer<World> {
     /// [`Cucumber`]: crate::event::Cucumber
     fn handle_event(
         &mut self,
-        ev: parser::Result<Event<event::Cucumber<World>>>,
+        event: parser::Result<Event<event::Cucumber<World>>>,
         cli: &Self::Cli,
     ) -> impl Future<Output = ()>;
 }
@@ -285,15 +285,15 @@ impl<T> Ext for T {
         FailOnSkipped::from(self)
     }
 
-    fn fail_on_skipped_with<F>(self, f: F) -> FailOnSkipped<Self, F>
+    fn fail_on_skipped_with<F>(self, with: F) -> FailOnSkipped<Self, F>
     where
         F: Fn(
             &gherkin::Feature,
             Option<&gherkin::Rule>,
             &gherkin::Scenario,
         ) -> bool,
     {
-        FailOnSkipped::with(self, f)
+        FailOnSkipped::with(self, with)
     }
 
     fn repeat_skipped<W>(self) -> Repeat<W, Self> {

src/writer/normalize.rs

@@ -702,17 +702,17 @@ impl<'me, World> Emitter<World> for &'me mut FeatureQueue<World> {
 
     async fn emit<W: Writer<World>>(
         self,
-        feature: Self::EmittedPath,
+        path: Self::EmittedPath,
         writer: &mut W,
         cli: &W::Cli,
     ) -> Option<Self::Emitted> {
         match self.current_item()? {
             Either::Left((rule, events)) => events
-                .emit((feature, rule), writer, cli)
+                .emit((path, rule), writer, cli)
                 .await
                 .map(Either::Left),
             Either::Right((scenario, events)) => events
-                .emit((feature, None, scenario), writer, cli)
+                .emit((path, None, scenario), writer, cli)
                 .await
                 .map(Either::Right),
         }

src/writer/or.rs

@@ -69,13 +69,13 @@ where
 
     async fn handle_event(
         &mut self,
-        ev: parser::Result<Event<event::Cucumber<W>>>,
+        event: parser::Result<Event<event::Cucumber<W>>>,
         cli: &Self::Cli,
     ) {
-        if (self.predicate)(&ev, cli) {
-            self.left.handle_event(ev, &cli.left).await;
+        if (self.predicate)(&event, cli) {
+            self.left.handle_event(event, &cli.left).await;
         } else {
-            self.right.handle_event(ev, &cli.right).await;
+            self.right.handle_event(event, &cli.right).await;
         }
     }
 }

src/writer/summarize.rs

@@ -202,7 +202,7 @@ where
 
     async fn handle_event(
         &mut self,
-        ev: parser::Result<Event<event::Cucumber<W>>>,
+        event: parser::Result<Event<event::Cucumber<W>>>,
         cli: &Self::Cli,
     ) {
         use event::{Cucumber, Feature, Rule};
@@ -212,7 +212,7 @@ where
         // This is done to avoid miscalculations if this `Writer` happens to be
         // wrapped by a `writer::Repeat` or similar.
         if matches!(self.state, State::InProgress) {
-            match ev.as_deref() {
+            match event.as_deref() {
                 Err(_) => self.parsing_errors += 1,
                 Ok(Cucumber::Feature(feat, ev)) => match ev {
                     Feature::Started => self.features += 1,
@@ -244,7 +244,7 @@ where
             };
         }
 
-        self.writer.handle_event(ev, cli).await;
+        self.writer.handle_event(event, cli).await;
 
         if matches!(self.state, State::FinishedButNotOutput) {
             self.state = State::FinishedAndOutput;

src/writer/tee.rs

@@ -60,12 +60,12 @@ where
 
     async fn handle_event(
         &mut self,
-        ev: parser::Result<Event<event::Cucumber<W>>>,
+        event: parser::Result<Event<event::Cucumber<W>>>,
         cli: &Self::Cli,
     ) {
         future::join(
-            self.left.handle_event(ev.clone(), &cli.left),
-            self.right.handle_event(ev, &cli.right),
+            self.left.handle_event(event.clone(), &cli.left),
+            self.right.handle_event(event, &cli.right),
         )
         .await;
     }