From 2ae5761eebee999b60dfe0d73eb532e6d790b5a0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 10 Nov 2021 17:25:09 +0000
Subject: [PATCH 1/5] Update inventory requirement from 0.1.10 to 0.2.0

Updates the requirements on [inventory](https://github.com/dtolnay/inventory) to permit the latest version.
- [Release notes](https://github.com/dtolnay/inventory/releases)
- [Commits](https://github.com/dtolnay/inventory/compare/0.1.10...0.2.0)

---
updated-dependencies:
- dependency-name: inventory
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 8e719c13..2c4f7015 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,7 +52,7 @@ structopt = "0.3.25"
 
 # "macros" feature dependencies
 cucumber-codegen = { version = "0.11.0-dev", path = "./codegen", optional = true }
-inventory = { version = "0.1.10", optional = true }
+inventory = { version = "0.2.0", optional = true }
 
 # "output-junit" feature dependencies
 junit-report = { version = "0.7", optional = true }

From 5e1aeb054c0e475e01e7d3cfb0247bd129f97891 Mon Sep 17 00:00:00 2001
From: ilslv <ilya.solovyiov@gmail.com>
Date: Thu, 11 Nov 2021 12:36:40 +0300
Subject: [PATCH 2/5] Upgrade to inventory 0.2

---
 README.md                |   1 -
 codegen/src/attribute.rs |  39 +++--
 codegen/src/derive.rs    | 369 +++++++++++++++++++++++++--------------
 src/cli.rs               |  14 +-
 src/codegen.rs           | 118 +++++--------
 src/cucumber.rs          |  99 ++++++-----
 src/lib.rs               |   5 +-
 src/step.rs              |   7 +-
 8 files changed, 379 insertions(+), 273 deletions(-)

diff --git a/README.md b/README.md
index 95a214e9..e42dc4a7 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,6 @@ Cucumber testing framework for Rust
 [![Documentation](https://docs.rs/cucumber/badge.svg)](https://docs.rs/cucumber)
 [![CI](https://github.com/cucumber-rs/cucumber/workflows/CI/badge.svg?branch=master "CI")](https://github.com/cucumber-rs/cucumber/actions?query=workflow%3ACI+branch%3Amaster)
 [![Rust 1.56+](https://img.shields.io/badge/rustc-1.56+-lightgray.svg "Rust 1.56+")](https://blog.rust-lang.org/2021/10/21/Rust-1.56.0.html)
-[![Unsafe Forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance)
 
 An implementation of the [Cucumber] testing framework for Rust. Fully native, no external test runners or dependencies.
 
diff --git a/codegen/src/attribute.rs b/codegen/src/attribute.rs
index 6a65c448..7d73dd89 100644
--- a/codegen/src/attribute.rs
+++ b/codegen/src/attribute.rs
@@ -12,6 +12,7 @@
 
 use std::mem;
 
+use inflections::case::to_pascal_case;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use regex::{self, Regex};
@@ -101,7 +102,7 @@ impl Step {
         let func_name = &func.sig.ident;
 
         let world = parse_world_from_args(&self.func.sig)?;
-        let constructor_method = self.constructor_method();
+        let step_type = self.step_type();
         let (func_args, addon_parsing) =
             self.fn_arguments_and_additional_parsing()?;
 
@@ -129,7 +130,8 @@ impl Step {
                     ::std::boxed::Box::pin(f)
                 }
 
-                #caller_name
+                let f: ::cucumber::Step<#world> = #caller_name;
+                f
             }
         };
 
@@ -138,19 +140,26 @@ impl Step {
 
             #[automatically_derived]
             ::cucumber::codegen::submit!(
-                #![crate = ::cucumber::codegen] {
-                    <#world as ::cucumber::codegen::WorldInventory<
-                        _, _, _,
-                    >>::#constructor_method(
+                {
+                    // SAFETY
+                    // `func` argument is transmuted from `cucumber::Step`.
+                    unsafe { <#world as ::cucumber::codegen::WorldInventory>::
+                    #step_type::new(
                         ::cucumber::step::Location {
-                            path: ::std::convert::From::from(::std::file!()),
+                            path: ::std::file!(),
                             line: ::std::line!(),
                             column: ::std::column!(),
                         },
-                        ::cucumber::codegen::Regex::new(#step_matcher)
-                            .unwrap(),
-                        #step_caller,
-                    )
+                        #step_matcher,
+                        // SAFETY
+                        // As we transmute fn pointer into `StepHack`, which is
+                        // `#[repr(C)]` over `*const ()`, this is safe on
+                        // platforms where fn pointers and data pointers have
+                        // the same sizes. Realistically this is every platform
+                        // supported by Rust.
+                        // https://bit.ly/3ogfQaZ
+                        unsafe { std::mem::transmute(#step_caller) },
+                    ) }
                 }
             );
         })
@@ -238,10 +247,10 @@ impl Step {
         }
     }
 
-    /// Composes a name of the `cucumber::codegen::WorldInventory` method to
-    /// wire this [`Step`] with.
-    fn constructor_method(&self) -> syn::Ident {
-        format_ident!("new_{}", self.attr_name)
+    /// Composes a name of the `cucumber::codegen::WorldInventory` associated
+    /// type to wire this [`Step`] with.
+    fn step_type(&self) -> syn::Ident {
+        format_ident!("{}", to_pascal_case(self.attr_name))
     }
 
     /// Returns [`syn::Ident`] and parsing code of the given function's
diff --git a/codegen/src/derive.rs b/codegen/src/derive.rs
index 507de42a..d9a08168 100644
--- a/codegen/src/derive.rs
+++ b/codegen/src/derive.rs
@@ -10,11 +10,12 @@
 
 //! `#[derive(WorldInit)]` macro implementation.
 
-use inflections::case::to_pascal_case;
-use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
+use inflections::case::{to_pascal_case, to_snake_case};
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
 
 /// Generates code of `#[derive(WorldInit)]` macro expansion.
+#[allow(clippy::similar_names)]
 pub(crate) fn world_init(
     input: TokenStream,
     steps: &[&str],
@@ -22,14 +23,23 @@ pub(crate) fn world_init(
     let input = syn::parse2::<syn::DeriveInput>(input)?;
 
     let world = &input.ident;
+    let (impl_gen, ty_gen, where_clause) = input.generics.split_for_impl();
 
     let step_types = step_types(steps, world);
     let step_structs = generate_step_structs(steps, &input);
 
+    let (given_mod, given_ty) = step_types[0].clone();
+    let (when_mod, when_ty) = step_types[1].clone();
+    let (then_mod, then_ty) = step_types[2].clone();
+
     Ok(quote! {
-        impl ::cucumber::codegen::WorldInventory<
-            #( #step_types, )*
-        > for #world {}
+        impl<#impl_gen> ::cucumber::codegen::WorldInventory for #world #ty_gen
+            #where_clause
+        {
+            type Given = #given_mod::#given_ty;
+            type When = #when_mod::#when_ty;
+            type Then = #then_mod::#then_ty;
+        }
 
         #( #step_structs )*
     })
@@ -38,12 +48,21 @@ pub(crate) fn world_init(
 /// Generates [`syn::Ident`]s of generic types for private trait impl.
 ///
 /// [`syn::Ident`]: struct@syn::Ident
-fn step_types(steps: &[&str], world: &syn::Ident) -> Vec<syn::Ident> {
+fn step_types(
+    steps: &[&str],
+    world: &syn::Ident,
+) -> Vec<(syn::Ident, syn::Ident)> {
     steps
         .iter()
         .map(|step| {
             let step = to_pascal_case(step);
-            format_ident!("Cucumber{}{}", step, world)
+            let ty = format!("Cucumber{}{}", step, world);
+            let m = to_snake_case(&ty);
+
+            (
+                syn::Ident::new(&m, Span::call_site()),
+                syn::Ident::new(&ty, Span::call_site()),
+            )
         })
         .collect()
 }
@@ -53,50 +72,73 @@ fn generate_step_structs(
     steps: &[&str],
     world: &syn::DeriveInput,
 ) -> Vec<TokenStream> {
-    let (world, world_vis) = (&world.ident, &world.vis);
+    let (impl_gen, ty_gen, where_clause) = world.generics.split_for_impl();
+    let world = &world.ident;
 
     step_types(steps, world)
         .iter()
-        .map(|ty| {
+        .map(|(m, ty)| {
             quote! {
                 #[automatically_derived]
                 #[doc(hidden)]
-                #world_vis struct #ty {
-                    #[doc(hidden)]
-                    pub loc: ::cucumber::step::Location,
+                pub mod #m {
+                    use super::*;
 
+                    #[automatically_derived]
                     #[doc(hidden)]
-                    pub regex: ::cucumber::codegen::Regex,
+                    pub struct #ty {
+                        #[doc(hidden)]
+                        loc: ::cucumber::step::Location,
 
-                    #[doc(hidden)]
-                    pub func: ::cucumber::Step<#world>,
-                }
+                        #[doc(hidden)]
+                        regex: &'static str,
 
-                #[automatically_derived]
-                impl ::cucumber::codegen::StepConstructor<#world> for #ty {
-                    fn new (
-                        loc: ::cucumber::step::Location,
-                        regex: ::cucumber::codegen::Regex,
-                        func: ::cucumber::Step<#world>,
-                    ) -> Self {
-                        Self { loc, regex, func }
+                        #[doc(hidden)]
+                        func: ::cucumber::codegen::SyncHack,
                     }
 
-                    fn inner(&self) -> (
-                        ::cucumber::step::Location,
-                        ::cucumber::codegen::Regex,
-                        ::cucumber::Step<#world>,
-                    ) {
-                        (
-                            self.loc.clone(),
-                            self.regex.clone(),
-                            self.func.clone(),
-                        )
+                    #[automatically_derived]
+                    impl #ty {
+                       #[doc(hidden)]
+                       /// # Safety
+                       ///
+                       /// `func` argument has to be [`transmute`]d from
+                       /// [`cucumber::Step`].
+                       ///
+                       /// [`transmute`]: std::mem::transmute
+                       pub const unsafe fn new (
+                           loc: ::cucumber::step::Location,
+                           regex: &'static str,
+                           func: ::cucumber::codegen::SyncHack,
+                       ) -> Self {
+                           Self { loc, regex, func }
+                       }
                     }
-                }
 
-                #[automatically_derived]
-                ::cucumber::codegen::collect!(#ty);
+                    #[automatically_derived]
+                    impl<#impl_gen> ::cucumber::codegen::StepConstructor<
+                        #world #ty_gen
+                    > for #ty #where_clause {
+                        fn inner(&self) -> (
+                            ::cucumber::step::Location,
+                            &'static str,
+                            ::cucumber::Step<#world #ty_gen>,
+                        ) {
+                            (
+                                self.loc.clone(),
+                                self.regex.clone(),
+                                // SAFETY
+                                // As the only way to construct `Self` in
+                                // calling `Self::new()` method, which enforces
+                                // right invariants.
+                                unsafe { ::std::mem::transmute(self.func) },
+                            )
+                        }
+                    }
+
+                    #[automatically_derived]
+                    ::cucumber::codegen::collect!(#ty);
+                }
             }
         })
         .collect()
@@ -114,132 +156,197 @@ mod spec {
         };
 
         let output = quote! {
-            impl ::cucumber::codegen::WorldInventory<
-                CucumberGivenWorld, CucumberWhenWorld, CucumberThenWorld,
-            > for World {}
+            impl<> ::cucumber::codegen::WorldInventory for World {
+                type Given = cucumber_given_world::CucumberGivenWorld;
+                type When = cucumber_when_world::CucumberWhenWorld;
+                type Then = cucumber_then_world::CucumberThenWorld;
+            }
 
             #[automatically_derived]
             #[doc(hidden)]
-            pub struct CucumberGivenWorld {
-                #[doc(hidden)]
-                pub loc: ::cucumber::step::Location,
+            pub mod cucumber_given_world {
+                use super::*;
 
+                #[automatically_derived]
                 #[doc(hidden)]
-                pub regex: ::cucumber::codegen::Regex,
+                pub struct CucumberGivenWorld {
+                     #[doc(hidden)]
+                     loc: ::cucumber::step::Location,
 
-                #[doc(hidden)]
-                pub func: ::cucumber::Step<World>,
-            }
+                     #[doc(hidden)]
+                     regex: &'static str,
 
-            #[automatically_derived]
-            impl ::cucumber::codegen::StepConstructor<World> for
-                CucumberGivenWorld
-            {
-                fn new (
-                    loc: ::cucumber::step::Location,
-                    regex: ::cucumber::codegen::Regex,
-                    func: ::cucumber::Step<World>,
-                ) -> Self {
-                    Self { loc, regex, func }
+                     #[doc(hidden)]
+                     func: ::cucumber::codegen::SyncHack,
                 }
 
-                fn inner(&self) -> (
-                    ::cucumber::step::Location,
-                    ::cucumber::codegen::Regex,
-                    ::cucumber::Step<World>,
-                ) {
-                    (
-                        self.loc.clone(),
-                        self.regex.clone(),
-                        self.func.clone(),
-                    )
+                #[automatically_derived]
+                impl CucumberGivenWorld {
+                   // TODO: Remove this method, once
+                   //       `<Struct as Trait>::Assoc { .. }` is supported.
+                   // https://github.com/rust-lang/rust/issues/86935
+                   #[doc(hidden)]
+                   /// # Safety
+                   ///
+                   /// `func` argument has to be [`transmute`]d from
+                   /// [`cucumber::Step`].
+                   ///
+                   /// [`transmute`]: std::mem::transmute
+                   pub const unsafe fn new (
+                       loc: ::cucumber::step::Location,
+                       regex: &'static str,
+                       func: ::cucumber::codegen::SyncHack,
+                   ) -> Self {
+                       Self { loc, regex, func }
+                   }
                 }
-            }
 
-            #[automatically_derived]
-            ::cucumber::codegen::collect!(CucumberGivenWorld);
+                #[automatically_derived]
+                impl<> ::cucumber::codegen::StepConstructor<World> for
+                    CucumberGivenWorld
+                {
+                    fn inner(&self) -> (
+                        ::cucumber::step::Location,
+                        &'static str,
+                        ::cucumber::Step<World>,
+                    ) {
+                        (
+                            self.loc.clone(),
+                            self.regex.clone(),
+                            // SAFETY
+                            // As the only way to construct `Self` in
+                            // calling `Self::new()` method, which enforces
+                            // right invariants.
+                            unsafe { ::std::mem::transmute(self.func) },
+                        )
+                    }
+                }
+
+                #[automatically_derived]
+                ::cucumber::codegen::collect!(CucumberGivenWorld);
+            }
 
             #[automatically_derived]
             #[doc(hidden)]
-            pub struct CucumberWhenWorld {
-                #[doc(hidden)]
-                pub loc: ::cucumber::step::Location,
+            pub mod cucumber_when_world {
+                use super::*;
 
+                #[automatically_derived]
                 #[doc(hidden)]
-                pub regex: ::cucumber::codegen::Regex,
+                pub struct CucumberWhenWorld {
+                     #[doc(hidden)]
+                     loc: ::cucumber::step::Location,
 
-                #[doc(hidden)]
-                pub func: ::cucumber::Step<World>,
-            }
+                     #[doc(hidden)]
+                     regex: &'static str,
 
-            #[automatically_derived]
-            impl ::cucumber::codegen::StepConstructor<World> for
-                CucumberWhenWorld
-            {
-                fn new (
-                    loc: ::cucumber::step::Location,
-                    regex: ::cucumber::codegen::Regex,
-                    func: ::cucumber::Step<World>,
-                ) -> Self {
-                    Self { loc, regex, func }
+                     #[doc(hidden)]
+                     func: ::cucumber::codegen::SyncHack,
                 }
 
-                fn inner(&self) -> (
-                    ::cucumber::step::Location,
-                    ::cucumber::codegen::Regex,
-                    ::cucumber::Step<World>,
-                ) {
-                    (
-                        self.loc.clone(),
-                        self.regex.clone(),
-                        self.func.clone(),
-                    )
+                #[automatically_derived]
+                impl CucumberWhenWorld {
+                   #[doc(hidden)]
+                   /// # Safety
+                   ///
+                   /// `func` argument has to be [`transmute`]d from
+                   /// [`cucumber::Step`].
+                   ///
+                   /// [`transmute`]: std::mem::transmute
+                   pub const unsafe fn new (
+                       loc: ::cucumber::step::Location,
+                       regex: &'static str,
+                       func: ::cucumber::codegen::SyncHack,
+                   ) -> Self {
+                       Self { loc, regex, func }
+                   }
                 }
-            }
 
-            #[automatically_derived]
-            ::cucumber::codegen::collect!(CucumberWhenWorld);
+                #[automatically_derived]
+                impl<> ::cucumber::codegen::StepConstructor<World> for
+                    CucumberWhenWorld
+                {
+                    fn inner(&self) -> (
+                        ::cucumber::step::Location,
+                        &'static str,
+                        ::cucumber::Step<World>,
+                    ) {
+                        (
+                            self.loc.clone(),
+                            self.regex.clone(),
+                            // SAFETY
+                            // As the only way to construct `Self` in
+                            // calling `Self::new()` method, which enforces
+                            // right invariants.
+                            unsafe { ::std::mem::transmute(self.func) },
+                        )
+                    }
+                }
+
+                #[automatically_derived]
+                ::cucumber::codegen::collect!(CucumberWhenWorld);
+            }
 
             #[automatically_derived]
             #[doc(hidden)]
-            pub struct CucumberThenWorld {
-                #[doc(hidden)]
-                pub loc: ::cucumber::step::Location,
+            pub mod cucumber_then_world {
+                use super::*;
 
+                #[automatically_derived]
                 #[doc(hidden)]
-                pub regex: ::cucumber::codegen::Regex,
+                pub struct CucumberThenWorld {
+                     #[doc(hidden)]
+                     loc: ::cucumber::step::Location,
 
-                #[doc(hidden)]
-                pub func: ::cucumber::Step<World>,
-            }
+                     #[doc(hidden)]
+                     regex: &'static str,
 
-            #[automatically_derived]
-            impl ::cucumber::codegen::StepConstructor<World> for
-                CucumberThenWorld
-            {
-                fn new (
-                    loc: ::cucumber::step::Location,
-                    regex: ::cucumber::codegen::Regex,
-                    func: ::cucumber::Step<World>,
-                ) -> Self {
-                    Self { loc, regex, func }
+                     #[doc(hidden)]
+                     func: ::cucumber::codegen::SyncHack,
                 }
 
-                fn inner(&self) -> (
-                    ::cucumber::step::Location,
-                    ::cucumber::codegen::Regex,
-                    ::cucumber::Step<World>,
-                ) {
-                    (
-                        self.loc.clone(),
-                        self.regex.clone(),
-                        self.func.clone(),
-                    )
+                #[automatically_derived]
+                impl CucumberThenWorld {
+                   #[doc(hidden)]
+                   /// # Safety
+                   ///
+                   /// `func` argument has to be [`transmute`]d from
+                   /// [`cucumber::Step`].
+                   ///
+                   /// [`transmute`]: std::mem::transmute
+                   pub const unsafe fn new (
+                       loc: ::cucumber::step::Location,
+                       regex: &'static str,
+                       func: ::cucumber::codegen::SyncHack,
+                   ) -> Self {
+                       Self { loc, regex, func }
+                   }
                 }
-            }
 
-            #[automatically_derived]
-            ::cucumber::codegen::collect!(CucumberThenWorld);
+                #[automatically_derived]
+                impl<> ::cucumber::codegen::StepConstructor<World> for
+                    CucumberThenWorld
+                {
+                    fn inner(&self) -> (
+                        ::cucumber::step::Location,
+                        &'static str,
+                        ::cucumber::Step<World>,
+                    ) {
+                        (
+                            self.loc.clone(),
+                            self.regex.clone(),
+                            // SAFETY
+                            // As the only way to construct `Self` in
+                            // calling `Self::new()` method, which enforces
+                            // right invariants.
+                            unsafe { ::std::mem::transmute(self.func) },
+                        )
+                    }
+                }
+
+                #[automatically_derived]
+                ::cucumber::codegen::collect!(CucumberThenWorld);
+            }
         };
 
         assert_eq!(
diff --git a/src/cli.rs b/src/cli.rs
index af66cb4c..3dfd5054 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -64,7 +64,8 @@ and may be extended with custom CLI options additionally.
 #     }
 # }
 #
-# let fut = async {
+# fn main() {
+#   let fut = async {
 #[derive(StructOpt)]
 struct CustomOpts {
     /// Additional time to wait in before hook.
@@ -85,11 +86,12 @@ MyWorld::cucumber()
     .await;
 # };
 #
-# tokio::runtime::Builder::new_current_thread()
-#    .enable_all()
-#    .build()
-#    .unwrap()
-#    .block_on(fut);
+#     tokio::runtime::Builder::new_current_thread()
+#        .enable_all()
+#        .build()
+#        .unwrap()
+#        .block_on(fut);
+# }
 ```
 
 [`Cucumber`]: crate::Cucumber
diff --git a/src/codegen.rs b/src/codegen.rs
index 3aef7d0c..8279d09f 100644
--- a/src/codegen.rs
+++ b/src/codegen.rs
@@ -22,13 +22,7 @@ pub use regex::Regex;
 
 /// [`World`] extension with auto-wiring capabilities.
 #[async_trait(?Send)]
-pub trait WorldInit<G, W, T>: WorldInventory<G, W, T>
-where
-    Self: Debug,
-    G: StepConstructor<Self> + inventory::Collect,
-    W: StepConstructor<Self> + inventory::Collect,
-    T: StepConstructor<Self> + inventory::Collect,
-{
+pub trait WorldInit: Debug + WorldInventory {
     /// Returns runner for tests with auto-wired steps marked by [`given`],
     /// [`when`] and [`then`] attributes.
     ///
@@ -39,19 +33,34 @@ where
     fn collection() -> step::Collection<Self> {
         let mut out = step::Collection::new();
 
-        for given in Self::cucumber_given() {
+        for given in inventory::iter::<Self::Given> {
             let (loc, regex, fun) = given.inner();
-            out = out.given(Some(loc), regex, fun);
+            out = out.given(
+                Some(loc),
+                Regex::new(regex)
+                    .unwrap_or_else(|e| panic!("Regex failed: {}", e)),
+                fun,
+            );
         }
 
-        for when in Self::cucumber_when() {
+        for when in inventory::iter::<Self::When> {
             let (loc, regex, fun) = when.inner();
-            out = out.when(Some(loc), regex, fun);
+            out = out.when(
+                Some(loc),
+                Regex::new(regex)
+                    .unwrap_or_else(|e| panic!("Regex failed: {}", e)),
+                fun,
+            );
         }
 
-        for then in Self::cucumber_then() {
+        for then in inventory::iter::<Self::Then> {
             let (loc, regex, fun) = then.inner();
-            out = out.then(Some(loc), regex, fun);
+            out = out.then(
+                Some(loc),
+                Regex::new(regex)
+                    .unwrap_or_else(|e| panic!("Regex failed: {}", e)),
+                fun,
+            );
         }
 
         out
@@ -112,70 +121,24 @@ where
     }
 }
 
-impl<G, W, T, E> WorldInit<G, W, T> for E
-where
-    Self: Debug,
-    G: StepConstructor<Self> + inventory::Collect,
-    W: StepConstructor<Self> + inventory::Collect,
-    T: StepConstructor<Self> + inventory::Collect,
-    E: WorldInventory<G, W, T>,
-{
-}
+impl<T> WorldInit for T where T: WorldInventory + Debug {}
 
 /// [`World`] extension allowing to register steps in [`inventory`].
-pub trait WorldInventory<G, W, T>: World
-where
-    G: StepConstructor<Self> + inventory::Collect,
-    W: StepConstructor<Self> + inventory::Collect,
-    T: StepConstructor<Self> + inventory::Collect,
-{
-    /// Returns an [`Iterator`] over items with [`given`] attribute.
+pub trait WorldInventory: World {
+    /// Struct [`submit`]ted in [`given`] macro.
     ///
     /// [`given`]: crate::given
-    #[must_use]
-    fn cucumber_given() -> inventory::iter<G> {
-        inventory::iter
-    }
-
-    /// Creates a new [`Given`] [`Step`] value. Used by [`given`] attribute.
-    ///
-    /// [`given`]: crate::given
-    /// [Given]: https://cucumber.io/docs/gherkin/reference/#given
-    fn new_given(loc: step::Location, regex: Regex, fun: Step<Self>) -> G {
-        G::new(loc, regex, fun)
-    }
+    type Given: inventory::Collect + StepConstructor<Self>;
 
-    /// Returns an [`Iterator`] over items with [`when`] attribute.
+    /// Struct [`submit`]ted in [`when`] macro.
     ///
     /// [`when`]: crate::when
-    #[must_use]
-    fn cucumber_when() -> inventory::iter<W> {
-        inventory::iter
-    }
-
-    /// Creates a new [`When`] [`Step`] value. Used by [`when`] attribute.
-    ///
-    /// [`when`]: crate::when
-    /// [When]: https://cucumber.io/docs/gherkin/reference/#when
-    fn new_when(loc: step::Location, regex: Regex, fun: Step<Self>) -> W {
-        W::new(loc, regex, fun)
-    }
+    type When: inventory::Collect + StepConstructor<Self>;
 
-    /// Returns an [`Iterator`] over items with [`then`] attribute.
+    /// Struct [`submit`]ted in [`then`] macro.
     ///
     /// [`then`]: crate::then
-    #[must_use]
-    fn cucumber_then() -> inventory::iter<T> {
-        inventory::iter
-    }
-
-    /// Creates a new [`Then`] [`Step`] value. Used by [`then`] attribute.
-    ///
-    /// [`then`]: crate::then
-    /// [Then]: https://cucumber.io/docs/gherkin/reference/#then
-    fn new_then(loc: step::Location, regex: Regex, fun: Step<Self>) -> T {
-        T::new(loc, regex, fun)
-    }
+    type Then: inventory::Collect + StepConstructor<Self>;
 }
 
 /// Trait for creating [`Step`]s to be registered by [`given`], [`when`] and
@@ -185,10 +148,21 @@ where
 /// [`when`]: crate::when
 /// [`then`]: crate::then
 pub trait StepConstructor<W> {
-    /// Creates a new [`Step`] with the corresponding [`Regex`].
-    #[must_use]
-    fn new(_: step::Location, _: Regex, _: Step<W>) -> Self;
-
     /// Returns an inner [`Step`] with the corresponding [`Regex`].
-    fn inner(&self) -> (step::Location, Regex, Step<W>);
+    fn inner(&self) -> (step::Location, &'static str, Step<W>);
 }
+
+/// Type used to hack around [`inventory::Collect`] requiring [`Sync`].
+///
+/// # Safety
+///
+/// As the only way to get this type is to [`transmute`] some other type, you
+/// have to be sure, that [`transmute`]d type is [`Sync`].
+///
+/// [`transmute`]: std::mem::transmute
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+pub struct SyncHack(*const ());
+
+#[allow(unsafe_code)]
+unsafe impl Sync for SyncHack {}
diff --git a/src/cucumber.rs b/src/cucumber.rs
index 49206a98..11d0c213 100644
--- a/src/cucumber.rs
+++ b/src/cucumber.rs
@@ -195,14 +195,15 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .repeat_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// # };
-    /// #
-    /// # futures::executor::block_on(fut);
+    /// #     };
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// <script
     ///     id="asciicast-ox14HynkBIw8atpfhyfvKrsO3"
@@ -249,14 +250,15 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// # };
-    /// #
-    /// # futures::executor::block_on(fut);
+    /// #     };
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// <script
     ///     id="asciicast-UcipuopO6IFEsIDty6vaJlCH9"
@@ -283,15 +285,16 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .repeat_failed()
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// # };
-    /// #
-    /// # futures::executor::block_on(fut);
+    /// #     };
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// <script
     ///     id="asciicast-ofOljvyEMb41OTLhE081QKv68"
@@ -347,14 +350,15 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// # };
-    /// #
-    /// # futures::executor::block_on(fut);
+    /// #     };
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// <script
     ///     id="asciicast-UcipuopO6IFEsIDty6vaJlCH9"
@@ -382,7 +386,8 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .repeat_if(|ev| {
     ///         use cucumber::event::{Cucumber, Feature, Rule, Scenario, Step};
@@ -409,9 +414,9 @@ where
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// # };
-    /// #
-    /// # futures::executor::block_on(fut);
+    /// #     };
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// <script
     ///     id="asciicast-ofOljvyEMb41OTLhE081QKv68"
@@ -489,14 +494,15 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// # };
-    /// #
-    /// # futures::executor::block_on(fut);
+    /// #     };
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// <script
     ///     id="asciicast-IHLxMEgku9BtBVkR4k2DtOjMd"
@@ -570,14 +576,15 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .fail_on_skipped_with(|_, _, s| !s.tags.iter().any(|t| t == "dog"))
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// # };
-    /// #
-    /// # futures::executor::block_on(fut);
+    /// #     };
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// ```gherkin
     /// Feature: Animal feature
@@ -694,7 +701,8 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// #[derive(StructOpt)]
     /// struct CustomCli {
     ///     /// Additional time to wait in a before hook.
@@ -713,13 +721,14 @@ where
     ///     .with_cli(cli)
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// # };
+    /// #    };
     /// #
-    /// # tokio::runtime::Builder::new_current_thread()
-    /// #    .enable_all()
-    /// #    .build()
-    /// #    .unwrap()
-    /// #    .block_on(fut);
+    /// #    tokio::runtime::Builder::new_current_thread()
+    /// #       .enable_all()
+    /// #       .build()
+    /// #       .unwrap()
+    /// #       .block_on(fut);
+    /// # }
     /// ```
     /// ```gherkin
     /// Feature: Animal feature
@@ -777,6 +786,9 @@ where
     /// #
     /// # #[derive(Debug, WorldInit)]
     /// # struct MyWorld;
+    /// mod te {
+    ///     use super::MyWorld;
+    /// }
     /// #
     /// # #[async_trait(?Send)]
     /// # impl cucumber::World for MyWorld {
@@ -787,15 +799,17 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .filter_run("tests/features/readme", |_, _, sc| {
     ///         sc.tags.iter().any(|t| t == "cat")
     ///     })
     ///     .await;
-    /// # };
+    /// #     };
     /// #
-    /// # futures::executor::block_on(fut);
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// ```gherkin
     /// Feature: Animal feature
@@ -1238,15 +1252,16 @@ where
     /// #     }
     /// # }
     /// #
-    /// # let fut = async {
+    /// # fn main() {
+    /// #     let fut = async {
     /// MyWorld::cucumber()
     ///     .filter_run_and_exit("tests/features/readme", |_, _, sc| {
     ///         sc.tags.iter().any(|t| t == "cat")
     ///     })
     ///     .await;
-    /// # };
-    /// #
-    /// # futures::executor::block_on(fut);
+    /// #     };
+    /// #     futures::executor::block_on(fut);
+    /// # }
     /// ```
     /// ```gherkin
     /// Feature: Animal feature
diff --git a/src/lib.rs b/src/lib.rs
index 47f4e146..cb30e633 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -20,9 +20,10 @@
     rustdoc::broken_intra_doc_links,
     rustdoc::private_intra_doc_links,
     trivial_casts,
-    trivial_numeric_casts
+    trivial_numeric_casts,
+    unsafe_code
 )]
-#![forbid(non_ascii_idents, unsafe_code)]
+#![forbid(non_ascii_idents)]
 #![warn(
     clippy::as_conversions,
     clippy::branches_sharing_code,
diff --git a/src/step.rs b/src/step.rs
index 06e00dd4..1ec15fa9 100644
--- a/src/step.rs
+++ b/src/step.rs
@@ -19,7 +19,6 @@ use std::{
     fmt,
     hash::{Hash, Hasher},
     iter,
-    path::PathBuf,
 };
 
 use derive_more::{Deref, DerefMut, Display, Error};
@@ -179,7 +178,7 @@ impl<World> Collection<World> {
                 return Err(AmbiguousMatchError {
                     possible_matches: matches
                         .into_iter()
-                        .map(|(re, loc, ..)| (re.clone(), loc.clone()))
+                        .map(|(re, loc, ..)| (re.clone(), *loc))
                         .collect(),
                 })
             }
@@ -229,10 +228,10 @@ pub struct AmbiguousMatchError {
 }
 
 /// Location of a [`Step`] [`fn`] automatically filled by a proc macro.
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct Location {
     /// Path to the file where [`Step`] [`fn`] is located.
-    pub path: PathBuf,
+    pub path: &'static str,
 
     /// Line of the file where [`Step`] [`fn`] is located.
     pub line: u32,

From 8856d1c185485d40a4eb39da1b916f934ed277b9 Mon Sep 17 00:00:00 2001
From: ilslv <ilya.solovyiov@gmail.com>
Date: Tue, 16 Nov 2021 08:53:46 +0300
Subject: [PATCH 3/5] Hack around const fn limitations

---
 README.md                |   1 +
 codegen/src/attribute.rs |  44 ++---
 codegen/src/derive.rs    | 341 +++++++++++----------------------------
 src/codegen.rs           |  15 --
 src/cucumber.rs          |   3 -
 src/lib.rs               |   5 +-
 6 files changed, 123 insertions(+), 286 deletions(-)

diff --git a/README.md b/README.md
index ed10e839..e8174e04 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,7 @@ Cucumber testing framework for Rust
 [![Documentation](https://docs.rs/cucumber/badge.svg)](https://docs.rs/cucumber)
 [![CI](https://github.com/cucumber-rs/cucumber/workflows/CI/badge.svg?branch=master "CI")](https://github.com/cucumber-rs/cucumber/actions?query=workflow%3ACI+branch%3Amaster)
 [![Rust 1.56+](https://img.shields.io/badge/rustc-1.56+-lightgray.svg "Rust 1.56+")](https://blog.rust-lang.org/2021/10/21/Rust-1.56.0.html)
+[![Unsafe Forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance)
 
 An implementation of the [Cucumber] testing framework for Rust. Fully native, no external test runners or dependencies.
 
diff --git a/codegen/src/attribute.rs b/codegen/src/attribute.rs
index 7d73dd89..d3e1891e 100644
--- a/codegen/src/attribute.rs
+++ b/codegen/src/attribute.rs
@@ -139,29 +139,29 @@ impl Step {
             #func
 
             #[automatically_derived]
-            ::cucumber::codegen::submit!(
-                {
-                    // SAFETY
-                    // `func` argument is transmuted from `cucumber::Step`.
-                    unsafe { <#world as ::cucumber::codegen::WorldInventory>::
-                    #step_type::new(
-                        ::cucumber::step::Location {
-                            path: ::std::file!(),
-                            line: ::std::line!(),
-                            column: ::std::column!(),
-                        },
-                        #step_matcher,
-                        // SAFETY
-                        // As we transmute fn pointer into `StepHack`, which is
-                        // `#[repr(C)]` over `*const ()`, this is safe on
-                        // platforms where fn pointers and data pointers have
-                        // the same sizes. Realistically this is every platform
-                        // supported by Rust.
-                        // https://bit.ly/3ogfQaZ
-                        unsafe { std::mem::transmute(#step_caller) },
-                    ) }
+            ::cucumber::codegen::submit!({
+                // TODO: remove this, once `#![feature(more_qualified_paths)]`
+                //       is stabilized.
+                //       https://github.com/rust-lang/rust/issues/86935
+                type StepAlias =
+                    <#world as ::cucumber::codegen::WorldInventory>::#step_type;
+
+                StepAlias {
+                    loc: ::cucumber::step::Location {
+                        path: ::std::file!(),
+                        line: ::std::line!(),
+                        column: ::std::column!(),
+                    },
+                    regex: #step_matcher,
+                    func: {
+                        // This hack exists, as `fn item` to `fn pointer`
+                        // coercion can be done inside `const`, but not
+                        // `const fn`.
+                        const F: ::cucumber::Step<#world> = #step_caller;
+                        F
+                    },
                 }
-            );
+            });
         })
     }
 
diff --git a/codegen/src/derive.rs b/codegen/src/derive.rs
index d9a08168..e47e7401 100644
--- a/codegen/src/derive.rs
+++ b/codegen/src/derive.rs
@@ -10,7 +10,7 @@
 
 //! `#[derive(WorldInit)]` macro implementation.
 
-use inflections::case::{to_pascal_case, to_snake_case};
+use inflections::case::to_pascal_case;
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 
@@ -23,22 +23,19 @@ pub(crate) fn world_init(
     let input = syn::parse2::<syn::DeriveInput>(input)?;
 
     let world = &input.ident;
-    let (impl_gen, ty_gen, where_clause) = input.generics.split_for_impl();
 
     let step_types = step_types(steps, world);
     let step_structs = generate_step_structs(steps, &input);
 
-    let (given_mod, given_ty) = step_types[0].clone();
-    let (when_mod, when_ty) = step_types[1].clone();
-    let (then_mod, then_ty) = step_types[2].clone();
+    let given_ty = step_types[0].clone();
+    let when_ty = step_types[1].clone();
+    let then_ty = step_types[2].clone();
 
     Ok(quote! {
-        impl<#impl_gen> ::cucumber::codegen::WorldInventory for #world #ty_gen
-            #where_clause
-        {
-            type Given = #given_mod::#given_ty;
-            type When = #when_mod::#when_ty;
-            type Then = #then_mod::#then_ty;
+        impl ::cucumber::codegen::WorldInventory for #world {
+            type Given = #given_ty;
+            type When = #when_ty;
+            type Then = #then_ty;
         }
 
         #( #step_structs )*
@@ -48,21 +45,12 @@ pub(crate) fn world_init(
 /// Generates [`syn::Ident`]s of generic types for private trait impl.
 ///
 /// [`syn::Ident`]: struct@syn::Ident
-fn step_types(
-    steps: &[&str],
-    world: &syn::Ident,
-) -> Vec<(syn::Ident, syn::Ident)> {
+fn step_types(steps: &[&str], world: &syn::Ident) -> Vec<syn::Ident> {
     steps
         .iter()
         .map(|step| {
-            let step = to_pascal_case(step);
-            let ty = format!("Cucumber{}{}", step, world);
-            let m = to_snake_case(&ty);
-
-            (
-                syn::Ident::new(&m, Span::call_site()),
-                syn::Ident::new(&ty, Span::call_site()),
-            )
+            let ty = format!("Cucumber{}{}", &to_pascal_case(step), world);
+            syn::Ident::new(&ty, Span::call_site())
         })
         .collect()
 }
@@ -72,73 +60,39 @@ fn generate_step_structs(
     steps: &[&str],
     world: &syn::DeriveInput,
 ) -> Vec<TokenStream> {
-    let (impl_gen, ty_gen, where_clause) = world.generics.split_for_impl();
+    let world_vis = &world.vis;
     let world = &world.ident;
 
     step_types(steps, world)
         .iter()
-        .map(|(m, ty)| {
+        .map(|ty| {
             quote! {
                 #[automatically_derived]
                 #[doc(hidden)]
-                pub mod #m {
-                    use super::*;
-
-                    #[automatically_derived]
+                #world_vis struct #ty {
                     #[doc(hidden)]
-                    pub struct #ty {
-                        #[doc(hidden)]
-                        loc: ::cucumber::step::Location,
-
-                        #[doc(hidden)]
-                        regex: &'static str,
+                    #world_vis loc: ::cucumber::step::Location,
 
-                        #[doc(hidden)]
-                        func: ::cucumber::codegen::SyncHack,
-                    }
+                    #[doc(hidden)]
+                    #world_vis regex: &'static str,
 
-                    #[automatically_derived]
-                    impl #ty {
-                       #[doc(hidden)]
-                       /// # Safety
-                       ///
-                       /// `func` argument has to be [`transmute`]d from
-                       /// [`cucumber::Step`].
-                       ///
-                       /// [`transmute`]: std::mem::transmute
-                       pub const unsafe fn new (
-                           loc: ::cucumber::step::Location,
-                           regex: &'static str,
-                           func: ::cucumber::codegen::SyncHack,
-                       ) -> Self {
-                           Self { loc, regex, func }
-                       }
-                    }
+                    #[doc(hidden)]
+                    #world_vis func: ::cucumber::Step<#world>,
+                }
 
-                    #[automatically_derived]
-                    impl<#impl_gen> ::cucumber::codegen::StepConstructor<
-                        #world #ty_gen
-                    > for #ty #where_clause {
-                        fn inner(&self) -> (
-                            ::cucumber::step::Location,
-                            &'static str,
-                            ::cucumber::Step<#world #ty_gen>,
-                        ) {
-                            (
-                                self.loc.clone(),
-                                self.regex.clone(),
-                                // SAFETY
-                                // As the only way to construct `Self` in
-                                // calling `Self::new()` method, which enforces
-                                // right invariants.
-                                unsafe { ::std::mem::transmute(self.func) },
-                            )
-                        }
+                #[automatically_derived]
+                impl ::cucumber::codegen::StepConstructor<#world> for #ty {
+                    fn inner(&self) -> (
+                        ::cucumber::step::Location,
+                        &'static str,
+                        ::cucumber::Step<#world>,
+                    ) {
+                        (self.loc, self.regex, self.func)
                     }
-
-                    #[automatically_derived]
-                    ::cucumber::codegen::collect!(#ty);
                 }
+
+                #[automatically_derived]
+                ::cucumber::codegen::collect!(#ty);
             }
         })
         .collect()
@@ -156,197 +110,98 @@ mod spec {
         };
 
         let output = quote! {
-            impl<> ::cucumber::codegen::WorldInventory for World {
-                type Given = cucumber_given_world::CucumberGivenWorld;
-                type When = cucumber_when_world::CucumberWhenWorld;
-                type Then = cucumber_then_world::CucumberThenWorld;
+            impl ::cucumber::codegen::WorldInventory for World {
+                type Given = CucumberGivenWorld;
+                type When = CucumberWhenWorld;
+                type Then = CucumberThenWorld;
             }
 
             #[automatically_derived]
             #[doc(hidden)]
-            pub mod cucumber_given_world {
-                use super::*;
-
-                #[automatically_derived]
-                #[doc(hidden)]
-                pub struct CucumberGivenWorld {
-                     #[doc(hidden)]
-                     loc: ::cucumber::step::Location,
+            pub struct CucumberGivenWorld {
+                 #[doc(hidden)]
+                 pub loc: ::cucumber::step::Location,
 
-                     #[doc(hidden)]
-                     regex: &'static str,
+                 #[doc(hidden)]
+                 pub regex: &'static str,
 
-                     #[doc(hidden)]
-                     func: ::cucumber::codegen::SyncHack,
-                }
-
-                #[automatically_derived]
-                impl CucumberGivenWorld {
-                   // TODO: Remove this method, once
-                   //       `<Struct as Trait>::Assoc { .. }` is supported.
-                   // https://github.com/rust-lang/rust/issues/86935
-                   #[doc(hidden)]
-                   /// # Safety
-                   ///
-                   /// `func` argument has to be [`transmute`]d from
-                   /// [`cucumber::Step`].
-                   ///
-                   /// [`transmute`]: std::mem::transmute
-                   pub const unsafe fn new (
-                       loc: ::cucumber::step::Location,
-                       regex: &'static str,
-                       func: ::cucumber::codegen::SyncHack,
-                   ) -> Self {
-                       Self { loc, regex, func }
-                   }
-                }
+                 #[doc(hidden)]
+                 pub func: ::cucumber::Step<World>,
+            }
 
-                #[automatically_derived]
-                impl<> ::cucumber::codegen::StepConstructor<World> for
-                    CucumberGivenWorld
-                {
-                    fn inner(&self) -> (
-                        ::cucumber::step::Location,
-                        &'static str,
-                        ::cucumber::Step<World>,
-                    ) {
-                        (
-                            self.loc.clone(),
-                            self.regex.clone(),
-                            // SAFETY
-                            // As the only way to construct `Self` in
-                            // calling `Self::new()` method, which enforces
-                            // right invariants.
-                            unsafe { ::std::mem::transmute(self.func) },
-                        )
-                    }
+            #[automatically_derived]
+            impl ::cucumber::codegen::StepConstructor<World> for
+                CucumberGivenWorld
+            {
+                fn inner(&self) -> (
+                    ::cucumber::step::Location,
+                    &'static str,
+                    ::cucumber::Step<World>,
+                ) {
+                    (self.loc, self.regex, self.func)
                 }
-
-                #[automatically_derived]
-                ::cucumber::codegen::collect!(CucumberGivenWorld);
             }
 
             #[automatically_derived]
-            #[doc(hidden)]
-            pub mod cucumber_when_world {
-                use super::*;
-
-                #[automatically_derived]
-                #[doc(hidden)]
-                pub struct CucumberWhenWorld {
-                     #[doc(hidden)]
-                     loc: ::cucumber::step::Location,
+            ::cucumber::codegen::collect!(CucumberGivenWorld);
 
-                     #[doc(hidden)]
-                     regex: &'static str,
+            #[automatically_derived]
+            #[doc(hidden)]
+            pub struct CucumberWhenWorld {
+                 #[doc(hidden)]
+                 pub loc: ::cucumber::step::Location,
 
-                     #[doc(hidden)]
-                     func: ::cucumber::codegen::SyncHack,
-                }
+                 #[doc(hidden)]
+                 pub regex: &'static str,
 
-                #[automatically_derived]
-                impl CucumberWhenWorld {
-                   #[doc(hidden)]
-                   /// # Safety
-                   ///
-                   /// `func` argument has to be [`transmute`]d from
-                   /// [`cucumber::Step`].
-                   ///
-                   /// [`transmute`]: std::mem::transmute
-                   pub const unsafe fn new (
-                       loc: ::cucumber::step::Location,
-                       regex: &'static str,
-                       func: ::cucumber::codegen::SyncHack,
-                   ) -> Self {
-                       Self { loc, regex, func }
-                   }
-                }
+                 #[doc(hidden)]
+                 pub func: ::cucumber::Step<World>,
+            }
 
-                #[automatically_derived]
-                impl<> ::cucumber::codegen::StepConstructor<World> for
-                    CucumberWhenWorld
-                {
-                    fn inner(&self) -> (
-                        ::cucumber::step::Location,
-                        &'static str,
-                        ::cucumber::Step<World>,
-                    ) {
-                        (
-                            self.loc.clone(),
-                            self.regex.clone(),
-                            // SAFETY
-                            // As the only way to construct `Self` in
-                            // calling `Self::new()` method, which enforces
-                            // right invariants.
-                            unsafe { ::std::mem::transmute(self.func) },
-                        )
-                    }
+            #[automatically_derived]
+            impl ::cucumber::codegen::StepConstructor<World> for
+                CucumberWhenWorld
+            {
+                fn inner(&self) -> (
+                    ::cucumber::step::Location,
+                    &'static str,
+                    ::cucumber::Step<World>,
+                ) {
+                    (self.loc, self.regex, self.func)
                 }
-
-                #[automatically_derived]
-                ::cucumber::codegen::collect!(CucumberWhenWorld);
             }
 
             #[automatically_derived]
-            #[doc(hidden)]
-            pub mod cucumber_then_world {
-                use super::*;
-
-                #[automatically_derived]
-                #[doc(hidden)]
-                pub struct CucumberThenWorld {
-                     #[doc(hidden)]
-                     loc: ::cucumber::step::Location,
+            ::cucumber::codegen::collect!(CucumberWhenWorld);
 
-                     #[doc(hidden)]
-                     regex: &'static str,
+            #[automatically_derived]
+            #[doc(hidden)]
+            pub struct CucumberThenWorld {
+                 #[doc(hidden)]
+                 pub loc: ::cucumber::step::Location,
 
-                     #[doc(hidden)]
-                     func: ::cucumber::codegen::SyncHack,
-                }
+                 #[doc(hidden)]
+                 pub regex: &'static str,
 
-                #[automatically_derived]
-                impl CucumberThenWorld {
-                   #[doc(hidden)]
-                   /// # Safety
-                   ///
-                   /// `func` argument has to be [`transmute`]d from
-                   /// [`cucumber::Step`].
-                   ///
-                   /// [`transmute`]: std::mem::transmute
-                   pub const unsafe fn new (
-                       loc: ::cucumber::step::Location,
-                       regex: &'static str,
-                       func: ::cucumber::codegen::SyncHack,
-                   ) -> Self {
-                       Self { loc, regex, func }
-                   }
-                }
+                 #[doc(hidden)]
+                 pub func: ::cucumber::Step<World>,
+            }
 
-                #[automatically_derived]
-                impl<> ::cucumber::codegen::StepConstructor<World> for
-                    CucumberThenWorld
-                {
-                    fn inner(&self) -> (
-                        ::cucumber::step::Location,
-                        &'static str,
-                        ::cucumber::Step<World>,
-                    ) {
-                        (
-                            self.loc.clone(),
-                            self.regex.clone(),
-                            // SAFETY
-                            // As the only way to construct `Self` in
-                            // calling `Self::new()` method, which enforces
-                            // right invariants.
-                            unsafe { ::std::mem::transmute(self.func) },
-                        )
-                    }
+            #[automatically_derived]
+            impl ::cucumber::codegen::StepConstructor<World> for
+                CucumberThenWorld
+            {
+                fn inner(&self) -> (
+                    ::cucumber::step::Location,
+                    &'static str,
+                    ::cucumber::Step<World>,
+                ) {
+                    (self.loc, self.regex, self.func)
                 }
-
-                #[automatically_derived]
-                ::cucumber::codegen::collect!(CucumberThenWorld);
             }
+
+            #[automatically_derived]
+            ::cucumber::codegen::collect!(CucumberThenWorld);
         };
 
         assert_eq!(
diff --git a/src/codegen.rs b/src/codegen.rs
index 8279d09f..632ef910 100644
--- a/src/codegen.rs
+++ b/src/codegen.rs
@@ -151,18 +151,3 @@ pub trait StepConstructor<W> {
     /// Returns an inner [`Step`] with the corresponding [`Regex`].
     fn inner(&self) -> (step::Location, &'static str, Step<W>);
 }
-
-/// Type used to hack around [`inventory::Collect`] requiring [`Sync`].
-///
-/// # Safety
-///
-/// As the only way to get this type is to [`transmute`] some other type, you
-/// have to be sure, that [`transmute`]d type is [`Sync`].
-///
-/// [`transmute`]: std::mem::transmute
-#[derive(Clone, Copy, Debug)]
-#[repr(C)]
-pub struct SyncHack(*const ());
-
-#[allow(unsafe_code)]
-unsafe impl Sync for SyncHack {}
diff --git a/src/cucumber.rs b/src/cucumber.rs
index 11d0c213..c9c4a4ad 100644
--- a/src/cucumber.rs
+++ b/src/cucumber.rs
@@ -786,9 +786,6 @@ where
     /// #
     /// # #[derive(Debug, WorldInit)]
     /// # struct MyWorld;
-    /// mod te {
-    ///     use super::MyWorld;
-    /// }
     /// #
     /// # #[async_trait(?Send)]
     /// # impl cucumber::World for MyWorld {
diff --git a/src/lib.rs b/src/lib.rs
index cb30e633..47f4e146 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -20,10 +20,9 @@
     rustdoc::broken_intra_doc_links,
     rustdoc::private_intra_doc_links,
     trivial_casts,
-    trivial_numeric_casts,
-    unsafe_code
+    trivial_numeric_casts
 )]
-#![forbid(non_ascii_idents)]
+#![forbid(non_ascii_idents, unsafe_code)]
 #![warn(
     clippy::as_conversions,
     clippy::branches_sharing_code,

From 3553623a75692188179da432d1686b0734568dd1 Mon Sep 17 00:00:00 2001
From: ilslv <ilya.solovyiov@gmail.com>
Date: Tue, 16 Nov 2021 09:20:08 +0300
Subject: [PATCH 4/5] Corrections

---
 codegen/src/attribute.rs | 14 +++++++++++++-
 codegen/src/derive.rs    | 25 +++++++++++--------------
 src/codegen.rs           | 33 +++++++++++----------------------
 3 files changed, 35 insertions(+), 37 deletions(-)

diff --git a/codegen/src/attribute.rs b/codegen/src/attribute.rs
index d3e1891e..5c50d0f3 100644
--- a/codegen/src/attribute.rs
+++ b/codegen/src/attribute.rs
@@ -152,7 +152,19 @@ impl Step {
                         line: ::std::line!(),
                         column: ::std::column!(),
                     },
-                    regex: #step_matcher,
+                    regex: {
+                        let lazy: ::cucumber::codegen::LazyRegex = || {
+                            static LAZY: ::cucumber::codegen::Lazy<
+                                ::cucumber::codegen::Regex
+                            > = ::cucumber::codegen::Lazy::new(|| {
+                                ::cucumber::codegen::Regex::new(#step_matcher)
+                                    .unwrap()
+                            });
+                            LAZY.clone()
+                        };
+
+                        lazy
+                    },
                     func: {
                         // This hack exists, as `fn item` to `fn pointer`
                         // coercion can be done inside `const`, but not
diff --git a/codegen/src/derive.rs b/codegen/src/derive.rs
index e47e7401..bc95b411 100644
--- a/codegen/src/derive.rs
+++ b/codegen/src/derive.rs
@@ -11,8 +11,8 @@
 //! `#[derive(WorldInit)]` macro implementation.
 
 use inflections::case::to_pascal_case;
-use proc_macro2::{Span, TokenStream};
-use quote::quote;
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
 
 /// Generates code of `#[derive(WorldInit)]` macro expansion.
 #[allow(clippy::similar_names)]
@@ -48,10 +48,7 @@ pub(crate) fn world_init(
 fn step_types(steps: &[&str], world: &syn::Ident) -> Vec<syn::Ident> {
     steps
         .iter()
-        .map(|step| {
-            let ty = format!("Cucumber{}{}", &to_pascal_case(step), world);
-            syn::Ident::new(&ty, Span::call_site())
-        })
+        .map(|step| format_ident!("Cucumber{}{}", to_pascal_case(step), world))
         .collect()
 }
 
@@ -74,7 +71,7 @@ fn generate_step_structs(
                     #world_vis loc: ::cucumber::step::Location,
 
                     #[doc(hidden)]
-                    #world_vis regex: &'static str,
+                    #world_vis regex: ::cucumber::codegen::LazyRegex,
 
                     #[doc(hidden)]
                     #world_vis func: ::cucumber::Step<#world>,
@@ -84,7 +81,7 @@ fn generate_step_structs(
                 impl ::cucumber::codegen::StepConstructor<#world> for #ty {
                     fn inner(&self) -> (
                         ::cucumber::step::Location,
-                        &'static str,
+                        ::cucumber::codegen::LazyRegex,
                         ::cucumber::Step<#world>,
                     ) {
                         (self.loc, self.regex, self.func)
@@ -123,7 +120,7 @@ mod spec {
                  pub loc: ::cucumber::step::Location,
 
                  #[doc(hidden)]
-                 pub regex: &'static str,
+                 pub regex: ::cucumber::codegen::LazyRegex,
 
                  #[doc(hidden)]
                  pub func: ::cucumber::Step<World>,
@@ -135,7 +132,7 @@ mod spec {
             {
                 fn inner(&self) -> (
                     ::cucumber::step::Location,
-                    &'static str,
+                    ::cucumber::codegen::LazyRegex,
                     ::cucumber::Step<World>,
                 ) {
                     (self.loc, self.regex, self.func)
@@ -152,7 +149,7 @@ mod spec {
                  pub loc: ::cucumber::step::Location,
 
                  #[doc(hidden)]
-                 pub regex: &'static str,
+                 pub regex: ::cucumber::codegen::LazyRegex,
 
                  #[doc(hidden)]
                  pub func: ::cucumber::Step<World>,
@@ -164,7 +161,7 @@ mod spec {
             {
                 fn inner(&self) -> (
                     ::cucumber::step::Location,
-                    &'static str,
+                    ::cucumber::codegen::LazyRegex,
                     ::cucumber::Step<World>,
                 ) {
                     (self.loc, self.regex, self.func)
@@ -181,7 +178,7 @@ mod spec {
                  pub loc: ::cucumber::step::Location,
 
                  #[doc(hidden)]
-                 pub regex: &'static str,
+                 pub regex: ::cucumber::codegen::LazyRegex,
 
                  #[doc(hidden)]
                  pub func: ::cucumber::Step<World>,
@@ -193,7 +190,7 @@ mod spec {
             {
                 fn inner(&self) -> (
                     ::cucumber::step::Location,
-                    &'static str,
+                    ::cucumber::codegen::LazyRegex,
                     ::cucumber::Step<World>,
                 ) {
                     (self.loc, self.regex, self.func)
diff --git a/src/codegen.rs b/src/codegen.rs
index 632ef910..2ddcf6db 100644
--- a/src/codegen.rs
+++ b/src/codegen.rs
@@ -18,6 +18,7 @@ use crate::{cucumber::DefaultCucumber, step, Cucumber, Step, World};
 
 pub use futures::future::LocalBoxFuture;
 pub use inventory::{self, collect, submit};
+pub use once_cell::sync::Lazy;
 pub use regex::Regex;
 
 /// [`World`] extension with auto-wiring capabilities.
@@ -35,32 +36,17 @@ pub trait WorldInit: Debug + WorldInventory {
 
         for given in inventory::iter::<Self::Given> {
             let (loc, regex, fun) = given.inner();
-            out = out.given(
-                Some(loc),
-                Regex::new(regex)
-                    .unwrap_or_else(|e| panic!("Regex failed: {}", e)),
-                fun,
-            );
+            out = out.given(Some(loc), regex(), fun);
         }
 
         for when in inventory::iter::<Self::When> {
             let (loc, regex, fun) = when.inner();
-            out = out.when(
-                Some(loc),
-                Regex::new(regex)
-                    .unwrap_or_else(|e| panic!("Regex failed: {}", e)),
-                fun,
-            );
+            out = out.when(Some(loc), regex(), fun);
         }
 
         for then in inventory::iter::<Self::Then> {
             let (loc, regex, fun) = then.inner();
-            out = out.then(
-                Some(loc),
-                Regex::new(regex)
-                    .unwrap_or_else(|e| panic!("Regex failed: {}", e)),
-                fun,
-            );
+            out = out.then(Some(loc), regex(), fun);
         }
 
         out
@@ -121,7 +107,7 @@ pub trait WorldInit: Debug + WorldInventory {
     }
 }
 
-impl<T> WorldInit for T where T: WorldInventory + Debug {}
+impl<T> WorldInit for T where T: Debug + WorldInventory {}
 
 /// [`World`] extension allowing to register steps in [`inventory`].
 pub trait WorldInventory: World {
@@ -141,13 +127,16 @@ pub trait WorldInventory: World {
     type Then: inventory::Collect + StepConstructor<Self>;
 }
 
-/// Trait for creating [`Step`]s to be registered by [`given`], [`when`] and
-/// [`then`] attributes.
+/// [`fn`] alias for [`Lazy`] [`Regex`].
+pub type LazyRegex = fn() -> Regex;
+
+/// Trait for registering [`Step`]s by [`given`], [`when`] and [`then`]
+/// attributes.
 ///
 /// [`given`]: crate::given
 /// [`when`]: crate::when
 /// [`then`]: crate::then
 pub trait StepConstructor<W> {
     /// Returns an inner [`Step`] with the corresponding [`Regex`].
-    fn inner(&self) -> (step::Location, &'static str, Step<W>);
+    fn inner(&self) -> (step::Location, LazyRegex, Step<W>);
 }

From b652afdf405b9818e7ffdad0032bf138635397a6 Mon Sep 17 00:00:00 2001
From: tyranron <tyranron@gmail.com>
Date: Tue, 16 Nov 2021 12:30:48 +0100
Subject: [PATCH 5/5] Corrections

---
 Cargo.toml               |  2 +-
 codegen/src/attribute.rs |  8 +++--
 codegen/src/derive.rs    |  6 ++--
 src/cli.rs               | 11 ++-----
 src/codegen.rs           | 12 ++++----
 src/cucumber.rs          | 66 ++++++++++++----------------------------
 tests/json.rs            |  4 +--
 tests/junit.rs           |  2 +-
 8 files changed, 40 insertions(+), 71 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ae81c13c..9988f307 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -54,7 +54,7 @@ structopt = "0.3.25"
 
 # "macros" feature dependencies
 cucumber-codegen = { version = "0.11.0-dev", path = "./codegen", optional = true }
-inventory = { version = "0.2.0", optional = true }
+inventory = { version = "0.2", optional = true }
 
 # "output-json" feature dependencies
 serde = { version = "1.0.103", features = ["derive"], optional = true }
diff --git a/codegen/src/attribute.rs b/codegen/src/attribute.rs
index 5c50d0f3..c9c9e3d5 100644
--- a/codegen/src/attribute.rs
+++ b/codegen/src/attribute.rs
@@ -140,8 +140,8 @@ impl Step {
 
             #[automatically_derived]
             ::cucumber::codegen::submit!({
-                // TODO: remove this, once `#![feature(more_qualified_paths)]`
-                //       is stabilized.
+                // TODO: Remove this, once `#![feature(more_qualified_paths)]`
+                //       is stabilized:
                 //       https://github.com/rust-lang/rust/issues/86935
                 type StepAlias =
                     <#world as ::cucumber::codegen::WorldInventory>::#step_type;
@@ -153,6 +153,9 @@ impl Step {
                         column: ::std::column!(),
                     },
                     regex: {
+                        // This hack exists, as `fn item` to `fn pointer`
+                        // coercion can be done inside `const`, but not
+                        // `const fn`.
                         let lazy: ::cucumber::codegen::LazyRegex = || {
                             static LAZY: ::cucumber::codegen::Lazy<
                                 ::cucumber::codegen::Regex
@@ -162,7 +165,6 @@ impl Step {
                             });
                             LAZY.clone()
                         };
-
                         lazy
                     },
                     func: {
diff --git a/codegen/src/derive.rs b/codegen/src/derive.rs
index bc95b411..cf5d3b8a 100644
--- a/codegen/src/derive.rs
+++ b/codegen/src/derive.rs
@@ -27,9 +27,9 @@ pub(crate) fn world_init(
     let step_types = step_types(steps, world);
     let step_structs = generate_step_structs(steps, &input);
 
-    let given_ty = step_types[0].clone();
-    let when_ty = step_types[1].clone();
-    let then_ty = step_types[2].clone();
+    let given_ty = &step_types[0];
+    let when_ty = &step_types[1];
+    let then_ty = &step_types[2];
 
     Ok(quote! {
         impl ::cucumber::codegen::WorldInventory for #world {
diff --git a/src/cli.rs b/src/cli.rs
index 3dfd5054..9b169374 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -64,8 +64,8 @@ and may be extended with custom CLI options additionally.
 #     }
 # }
 #
-# fn main() {
-#   let fut = async {
+# #[tokio::main(flavor = "current_thread")]
+# async fn main() {
 #[derive(StructOpt)]
 struct CustomOpts {
     /// Additional time to wait in before hook.
@@ -84,13 +84,6 @@ MyWorld::cucumber()
     .with_cli(opts)
     .run_and_exit("tests/features/readme")
     .await;
-# };
-#
-#     tokio::runtime::Builder::new_current_thread()
-#        .enable_all()
-#        .build()
-#        .unwrap()
-#        .block_on(fut);
 # }
 ```
 
diff --git a/src/codegen.rs b/src/codegen.rs
index 2ddcf6db..a774368e 100644
--- a/src/codegen.rs
+++ b/src/codegen.rs
@@ -111,27 +111,27 @@ impl<T> WorldInit for T where T: Debug + WorldInventory {}
 
 /// [`World`] extension allowing to register steps in [`inventory`].
 pub trait WorldInventory: World {
-    /// Struct [`submit`]ted in [`given`] macro.
+    /// Struct [`submit`]ted in a [`given`] macro.
     ///
     /// [`given`]: crate::given
     type Given: inventory::Collect + StepConstructor<Self>;
 
-    /// Struct [`submit`]ted in [`when`] macro.
+    /// Struct [`submit`]ted in a [`when`] macro.
     ///
     /// [`when`]: crate::when
     type When: inventory::Collect + StepConstructor<Self>;
 
-    /// Struct [`submit`]ted in [`then`] macro.
+    /// Struct [`submit`]ted in a [`then`] macro.
     ///
     /// [`then`]: crate::then
     type Then: inventory::Collect + StepConstructor<Self>;
 }
 
-/// [`fn`] alias for [`Lazy`] [`Regex`].
+/// Alias for a [`fn`] returning a [`Lazy`] [`Regex`].
 pub type LazyRegex = fn() -> Regex;
 
-/// Trait for registering [`Step`]s by [`given`], [`when`] and [`then`]
-/// attributes.
+/// Trait for registering a [`Step`] with [`given`], [`when`] and [`then`]
+/// attributes inside [`WorldInit::collection()`] method.
 ///
 /// [`given`]: crate::given
 /// [`when`]: crate::when
diff --git a/src/cucumber.rs b/src/cucumber.rs
index c9c4a4ad..c20c05cd 100644
--- a/src/cucumber.rs
+++ b/src/cucumber.rs
@@ -195,14 +195,12 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .repeat_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// #     };
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// <script
@@ -250,14 +248,12 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// #     };
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// <script
@@ -285,15 +281,13 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .repeat_failed()
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// #     };
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// <script
@@ -350,14 +344,12 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// #     };
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// <script
@@ -386,8 +378,8 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .repeat_if(|ev| {
     ///         use cucumber::event::{Cucumber, Feature, Rule, Scenario, Step};
@@ -414,8 +406,6 @@ where
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// #     };
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// <script
@@ -494,14 +484,12 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .fail_on_skipped()
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// #     };
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// <script
@@ -576,14 +564,12 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .fail_on_skipped_with(|_, _, s| !s.tags.iter().any(|t| t == "dog"))
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// #     };
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// ```gherkin
@@ -701,8 +687,8 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// #[derive(StructOpt)]
     /// struct CustomCli {
     ///     /// Additional time to wait in a before hook.
@@ -721,13 +707,6 @@ where
     ///     .with_cli(cli)
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
-    /// #    };
-    /// #
-    /// #    tokio::runtime::Builder::new_current_thread()
-    /// #       .enable_all()
-    /// #       .build()
-    /// #       .unwrap()
-    /// #       .block_on(fut);
     /// # }
     /// ```
     /// ```gherkin
@@ -796,16 +775,13 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .filter_run("tests/features/readme", |_, _, sc| {
     ///         sc.tags.iter().any(|t| t == "cat")
     ///     })
     ///     .await;
-    /// #     };
-    /// #
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// ```gherkin
@@ -1249,15 +1225,13 @@ where
     /// #     }
     /// # }
     /// #
-    /// # fn main() {
-    /// #     let fut = async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
     /// MyWorld::cucumber()
     ///     .filter_run_and_exit("tests/features/readme", |_, _, sc| {
     ///         sc.tags.iter().any(|t| t == "cat")
     ///     })
     ///     .await;
-    /// #     };
-    /// #     futures::executor::block_on(fut);
     /// # }
     /// ```
     /// ```gherkin
diff --git a/tests/json.rs b/tests/json.rs
index 6a7eef77..d7b1e7d5 100644
--- a/tests/json.rs
+++ b/tests/json.rs
@@ -1,9 +1,9 @@
 use std::{convert::Infallible, fs, io::Read as _};
 
 use async_trait::async_trait;
-use cucumber::{given, then, when, writer, WorldInit, WriterExt as _};
+use cucumber::{given, then, when, writer, WorldInit};
 use futures::FutureExt as _;
-use regex::{Regex, RegexBuilder};
+use regex::RegexBuilder;
 use tempfile::NamedTempFile;
 
 #[given(regex = r"(\d+) secs?")]
diff --git a/tests/junit.rs b/tests/junit.rs
index 7621ac5b..606d270c 100644
--- a/tests/junit.rs
+++ b/tests/junit.rs
@@ -1,7 +1,7 @@
 use std::{convert::Infallible, fs, io::Read as _};
 
 use async_trait::async_trait;
-use cucumber::{given, then, when, writer, WorldInit, WriterExt as _};
+use cucumber::{given, then, when, writer, WorldInit};
 use regex::Regex;
 use tempfile::NamedTempFile;