Switch to 2024 Rust edition

- bump up MSRV to 1.85
- tune lints for 1.85 Rust
- revisit `rustfmt` rules

Author: tyranron

.github/workflows/ci.yml

@@ -101,7 +101,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        msrv: ["1.81.0"]
+        msrv: ["1.85.0"]
         os: ["ubuntu", "macOS", "windows"]
     runs-on: ${{ matrix.os }}-latest
     steps:

.rustfmt.toml

@@ -3,9 +3,12 @@
 # https://github.com/rust-lang/rustfmt/blob/master/Configurations.md
 
 max_width = 80
-format_strings = false
+use_small_heuristics = "Max"
+
+group_imports = "StdExternalCrate"
 imports_granularity = "Crate"
 
+format_strings = false
 format_code_in_doc_comments = true
 format_macro_matchers = true
 use_try_shorthand = true

CHANGELOG.md

@@ -6,6 +6,19 @@ All user visible changes to `cucumber-expressions` crate will be documented in t
 
 
 
+## main
+
+[Diff](https://github.com/cucumber-rs/cucumber-expressions/compare/v0.4.0...main)
+
+### BC Breaks
+
+- Bumped up [MSRV] to 1.85 because of migration to 2024 edition. ([todo])
+
+[todo]: https://github.com/cucumber-rs/cucumber-expressions/commit/todo
+
+
+
+
 ## [0.4.0] · 2025-02-03
 [0.4.0]: https://github.com/cucumber-rs/cucumber-expressions/tree/v0.4.0
 

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "cucumber-expressions"
 version = "0.4.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.85"
 description = "Cucumber Expressions AST and parser."
 license = "MIT OR Apache-2.0"
 authors = [

README.md

@@ -2,7 +2,7 @@
 ===============================
 
 [![crates.io](https://img.shields.io/crates/v/cucumber-expressions.svg?maxAge=2592000 "crates.io")](https://crates.io/crates/cucumber-expressions)
-[![Rust 1.81+](https://img.shields.io/badge/rustc-1.81+-lightgray.svg "Rust 1.81+")](https://blog.rust-lang.org/2024/09/05/Rust-1.81.0.html)
+[![Rust 1.85+](https://img.shields.io/badge/rustc-1.85+-lightgray.svg "Rust 1.85+")](https://blog.rust-lang.org/2025/02/20/Rust-1.85.0.html)
 [![Unsafe Forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg "Unsafe forbidden")](https://github.com/rust-secure-code/safety-dance)  
 [![CI](https://github.com/cucumber-rs/cucumber-expressions/actions/workflows/ci.yml/badge.svg?branch=main "CI")](https://github.com/cucumber-rs/cucumber-expressions/actions?query=workflow%3ACI+branch%3Amain)
 [![Rust docs](https://docs.rs/cucumber-expressions/badge.svg "Rust docs")](https://docs.rs/cucumber-expressions)

fuzz/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "cucumber-expressions-fuzz"
 version = "0.0.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.85"
 description = "Fuzz testing for `cucumber-expressions` crate."
 license = "MIT OR Apache-2.0"
 authors = [

src/ast.rs

@@ -17,7 +17,7 @@
 //! [AST]: https://en.wikipedia.org/wiki/Abstract_syntax_tree
 
 use derive_more::with_trait::{AsRef, Deref, DerefMut};
-use nom::{error::ErrorKind, Err, Input};
+use nom::{Err, Input, error::ErrorKind};
 use nom_locate::LocatedSpan;
 
 use crate::parse;
@@ -131,9 +131,7 @@ impl<I: Input> Alternation<I> {
     /// [`Optional`]s.
     pub(crate) fn contains_only_optional(&self) -> bool {
         (**self).iter().any(|single_alt| {
-            single_alt
-                .iter()
-                .all(|alt| matches!(alt, Alternative::Optional(_)))
+            single_alt.iter().all(|alt| matches!(alt, Alternative::Optional(_)))
         })
     }
 }

src/combinator.rs

@@ -11,8 +11,8 @@
 //! Helper parser combinators.
 
 use nom::{
-    error::{ErrorKind, ParseError},
     AsChar, Err, IResult, Input, Offset, Parser,
+    error::{ErrorKind, ParseError},
 };
 
 /// Applies the given `map` function to the `parser`'s [`IResult`] in case it
@@ -44,13 +44,13 @@ where
 ///    non-`escapable` `Input` or end of line.
 ///
 /// [`escaped()`]: nom::bytes::complete::escaped()
-pub(crate) fn escaped0<'a, I, Error, F, G>(
+pub(crate) fn escaped0<I, Error, F, G>(
     mut normal: F,
     control_char: char,
     mut escapable: G,
 ) -> impl FnMut(I) -> IResult<I, I, Error>
 where
-    I: Clone + Offset + Input + 'a,
+    I: Clone + Offset + Input,
     <I as Input>::Item: AsChar,
     F: Parser<I, Error = Error>,
     G: Parser<I, Error = Error>,
@@ -130,10 +130,10 @@ where
 #[cfg(test)]
 mod escaped0_spec {
     use nom::{
+        Err, IResult,
         bytes::complete::escaped,
         character::complete::{digit0, digit1, one_of},
         error::{Error, ErrorKind},
-        Err, IResult,
     };
 
     use super::escaped0;

src/expand/mod.rs

@@ -26,14 +26,13 @@ use either::Either;
 use nom::{AsChar, Input};
 use regex::Regex;
 
-use crate::{
-    parse, Alternation, Alternative, Expression, Optional, Parameter,
-    SingleAlternation, SingleExpression, Spanned,
-};
-
 pub use self::parameters::{
     Provider as ParametersProvider, WithCustom as WithCustomParameters,
 };
+use crate::{
+    Alternation, Alternative, Expression, Optional, Parameter,
+    SingleAlternation, SingleExpression, Spanned, parse,
+};
 
 impl<'s> Expression<Spanned<'s>> {
     /// Parses the given `input` as an [`Expression`], and immediately expands
@@ -93,11 +92,9 @@ impl<'s> Expression<Spanned<'s>> {
     ///     &parameters,
     /// )
     /// .unwrap();
+    /// let re = re.as_str();
     ///
-    /// assert_eq!(
-    ///     re.as_str(),
-    ///     "^([^\\s]+) has ([Rr]ed|[Gg]reen|[Bb]lue) eyes$",
-    /// );
+    /// assert_eq!(re, "^([^\\s]+) has ([Rr]ed|[Gg]reen|[Bb]lue) eyes$");
     /// ```
     ///
     /// [`Error`]: enum@Error
@@ -128,10 +125,7 @@ impl<'s> Expression<Spanned<'s>> {
         self,
         parameters: P,
     ) -> WithCustomParameters<Self, P> {
-        WithCustomParameters {
-            element: self,
-            parameters,
-        }
+        WithCustomParameters { element: self, parameters }
     }
 }
 
@@ -488,18 +482,14 @@ where
     Iter::Item: Clone,
 {
     fn clone(&self) -> Self {
-        Self {
-            iter: self.iter.clone(),
-        }
+        Self { iter: self.iter.clone() }
     }
 }
 
 impl<Iter: Iterator> SkipLast<Iter> {
     /// Creates a new [`SkipLast`] [`Iterator`].
     pub fn new(iter: Iter) -> Self {
-        Self {
-            iter: iter.peekable(),
-        }
+        Self { iter: iter.peekable() }
     }
 }
 
@@ -572,10 +562,7 @@ pub struct EscapeForRegex<Iter: Iterator> {
 impl<Iter: Iterator> EscapeForRegex<Iter> {
     /// Creates a new [`EscapeForRegex`] [`Iterator`].
     pub fn new(iter: Iter) -> Self {
-        Self {
-            iter: iter.peekable(),
-            was_escaped: None,
-        }
+        Self { iter: iter.peekable(), was_escaped: None }
     }
 }
 

src/expand/parameters.rs

@@ -17,12 +17,11 @@ use std::{collections::HashMap, fmt::Display, iter, str, vec};
 use either::Either;
 use nom::{AsChar, Input};
 
-use crate::{expand::OwnedChars, Parameter, SingleExpression};
-
 use super::{
     Expression, IntoRegexCharIter, ParameterError, ParameterIter,
     SingleExpressionIter,
 };
+use crate::{Parameter, SingleExpression, expand::OwnedChars};
 
 /// Parser of a [Cucumber Expressions][0] [AST] `Element` with [custom][1]
 /// `Parameters` in mind.
@@ -106,10 +105,8 @@ where
     type Iter = ExpressionWithParsIter<I, Pars>;
 
     fn into_regex_char_iter(self) -> Self::Iter {
-        let add_pars: fn(_) -> _ = |(item, parameters)| WithCustom {
-            element: item,
-            parameters,
-        };
+        let add_pars: fn(_) -> _ =
+            |(item, parameters)| WithCustom { element: item, parameters };
         let into_regex_char_iter: fn(_) -> _ =
             IntoRegexCharIter::into_regex_char_iter;
         iter::once(Ok('^'))
@@ -161,11 +158,8 @@ where
 
         if let SingleExpression::Parameter(item) = self.element {
             Left(
-                WithCustom {
-                    element: item,
-                    parameters: self.parameters,
-                }
-                .into_regex_char_iter(),
+                WithCustom { element: item, parameters: self.parameters }
+                    .into_regex_char_iter(),
             )
         } else {
             Right(self.element.into_regex_char_iter())
@@ -383,9 +377,8 @@ mod regex_hir {
 
 #[cfg(test)]
 mod spec {
-    use crate::expand::Error;
-
     use super::{Expression, HashMap, ParameterError};
+    use crate::expand::Error;
 
     #[test]
     fn custom_parameter() {

src/lib.rs

@@ -12,22 +12,17 @@
     html_logo_url = "https://avatars.githubusercontent.com/u/91469139?s=128",
     html_favicon_url = "https://avatars.githubusercontent.com/u/91469139?s=256"
 )]
-#![doc = include_str!("../README.md")]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![deny(
-    macro_use_extern_crate,
-    nonstandard_style,
-    rust_2018_idioms,
-    rustdoc::all,
-    trivial_casts,
-    trivial_numeric_casts
-)]
+#![cfg_attr(any(doc, test), doc = include_str!("../README.md"))]
+#![cfg_attr(not(any(doc, test)), doc = env!("CARGO_PKG_NAME"))]
+#![deny(nonstandard_style, rustdoc::all, trivial_casts, trivial_numeric_casts)]
 #![forbid(non_ascii_idents, unsafe_code)]
 #![warn(
     clippy::absolute_paths,
     clippy::allow_attributes,
     clippy::allow_attributes_without_reason,
     clippy::as_conversions,
+    clippy::as_pointer_underscore,
     clippy::as_ptr_cast_mut,
     clippy::assertions_on_result_states,
     clippy::branches_sharing_code,
@@ -41,6 +36,7 @@
     clippy::decimal_literal_representation,
     clippy::default_union_representation,
     clippy::derive_partial_eq_without_eq,
+    clippy::doc_include_without_cfg,
     clippy::else_if_without_else,
     clippy::empty_drop,
     clippy::empty_structs_with_brackets,
@@ -64,6 +60,7 @@
     clippy::large_include_file,
     clippy::large_stack_frames,
     clippy::let_underscore_untyped,
+    clippy::literal_string_with_formatting_args,
     clippy::lossy_float_literal,
     clippy::map_err_ignore,
     clippy::map_with_unused_argument_over_ranges,
@@ -140,29 +137,25 @@
     clippy::verbose_file_reads,
     clippy::while_float,
     clippy::wildcard_enum_match_arm,
-    explicit_outlives_requirements,
+    ambiguous_negative_literals,
+    closure_returning_async_block,
     future_incompatible,
+    impl_trait_redundant_captures,
     let_underscore_drop,
+    macro_use_extern_crate,
     meta_variable_misuse,
     missing_abi,
     missing_copy_implementations,
     missing_debug_implementations,
     missing_docs,
     redundant_lifetimes,
-    semicolon_in_expressions_from_macros,
+    rust_2018_idioms,
     single_use_lifetimes,
     unit_bindings,
     unnameable_types,
     unreachable_pub,
-    unsafe_op_in_unsafe_fn,
     unstable_features,
-    unused_crate_dependencies,
-    unused_extern_crates,
-    unused_import_braces,
-    unused_lifetimes,
-    unused_macro_rules,
-    unused_qualifications,
-    unused_results,
+    unused,
     variant_size_differences
 )]