Harden rustc and Clippy lints even more

Author: tyranron

.clippy.toml

@@ -0,0 +1,10 @@
+# Project configuration for Clippy Rust code linter.
+# See full lints list at:
+# https://rust-lang.github.io/rust-clippy/master/index.html
+
+standard-macro-braces = [
+    { name = "format", brace = "(" },
+    { name = "format_ident", brace = "(" },
+    { name = "quote", brace = "{" },
+    { name = "vec", brace = "[" },
+]

Makefile

@@ -67,7 +67,7 @@ cargo.fmt:
 #	make cargo.lint
 
 cargo.lint:
-	cargo clippy --workspace -- -D clippy::pedantic -D warnings
+	cargo clippy --workspace -- -D warnings
 
 
 

codegen/src/attribute.rs

@@ -67,16 +67,11 @@ impl Step {
             match arg_marked_as_step.len() {
                 0 => Ok(None),
                 1 => {
-                    // Unwrapping is OK here, because
-                    // `arg_marked_as_step.len() == 1`.
-                    let (ident, _) =
-                        parse_fn_arg(arg_marked_as_step.first().unwrap())?;
+                    let (ident, _) = parse_fn_arg(arg_marked_as_step[0])?;
                     Ok(Some(ident.clone()))
                 }
                 _ => Err(syn::Error::new(
-                    // Unwrapping is OK here, because
-                    // `arg_marked_as_step.len() > 1`.
-                    arg_marked_as_step.get(1).unwrap().span(),
+                    arg_marked_as_step[1].span(),
                     "Only 1 step argument is allowed",
                 )),
             }
@@ -255,21 +250,23 @@ impl Step {
                     ::std::borrow::Borrow::borrow(&__cucumber_ctx.step);
             }
         } else {
-            let ty = match ty {
-                syn::Type::Path(p) => p,
-                _ => {
-                    return Err(syn::Error::new(
-                        ty.span(),
-                        "Type path expected",
-                    ))
-                }
+            let ty = if let syn::Type::Path(p) = ty {
+                p
+            } else {
+                return Err(syn::Error::new(ty.span(), "Type path expected"));
             };
 
             let not_found_err = format!("{} not found", ident);
             let parsing_err = format!(
                 "{} can not be parsed to {}",
                 ident,
-                ty.path.segments.last().unwrap().ident
+                ty.path
+                    .segments
+                    .last()
+                    .ok_or_else(|| {
+                        syn::Error::new(ty.path.span(), "Type path expected")
+                    })?
+                    .ident,
             );
 
             quote! {
@@ -349,15 +346,13 @@ impl Parse for AttributeArgument {
                         },
                     )?);
 
-                    Ok(AttributeArgument::Regex(str_lit))
+                    Ok(Self::Regex(str_lit))
                 } else {
                     Err(syn::Error::new(arg.span(), "Expected regex argument"))
                 }
             }
 
-            syn::NestedMeta::Lit(l) => {
-                Ok(AttributeArgument::Literal(to_string_literal(l)?))
-            }
+            syn::NestedMeta::Lit(l) => Ok(Self::Literal(to_string_literal(l)?)),
 
             syn::NestedMeta::Meta(_) => Err(syn::Error::new(
                 arg.span(),
@@ -391,13 +386,11 @@ fn remove_all_attrs_if_needed<'a>(
         .iter_mut()
         .filter_map(|arg| {
             if has_other_step_arguments {
-                if let Some(attr) = find_attr(attr_arg, arg) {
-                    return Some((&*arg, attr));
-                }
-            } else if let Some(attr) = remove_attr(attr_arg, arg) {
-                return Some((&*arg, attr));
+                find_attr(attr_arg, arg)
+            } else {
+                remove_attr(attr_arg, arg)
             }
-            None
+            .map(move |attr| (&*arg, attr))
         })
         .unzip()
 }
@@ -439,8 +432,7 @@ fn remove_attr(attr_arg: &str, arg: &mut syn::FnArg) -> Option<syn::Attribute> {
 
         if removed.len() == 1 {
             typed_arg.attrs = other;
-            // Unwrapping is OK here, because `step_idents.len() == 1`.
-            return Some(removed.pop().unwrap());
+            return removed.pop();
         }
         other.append(&mut removed);
         typed_arg.attrs = other;
@@ -462,9 +454,10 @@ fn parse_fn_arg(arg: &syn::FnArg) -> syn::Result<(&syn::Ident, &syn::Type)> {
         }
     };
 
-    let ident = match arg.pat.as_ref() {
-        syn::Pat::Ident(i) => &i.ident,
-        _ => return Err(syn::Error::new(arg.span(), "Expected ident")),
+    let ident = if let syn::Pat::Ident(i) = arg.pat.as_ref() {
+        &i.ident
+    } else {
+        return Err(syn::Error::new(arg.span(), "Expected ident"));
     };
 
     Ok((ident, arg.ty.as_ref()))
@@ -478,18 +471,23 @@ fn find_first_slice(sig: &syn::Signature) -> Option<&syn::TypePath> {
             syn::FnArg::Receiver(_) => None,
         }
         .and_then(|typed_arg| {
-            match typed_arg.ty.as_ref() {
-                syn::Type::Reference(r) => Some(r),
-                _ => None,
+            if let syn::Type::Reference(r) = typed_arg.ty.as_ref() {
+                Some(r)
+            } else {
+                None
             }
             .and_then(|ty_ref| {
-                match ty_ref.elem.as_ref() {
-                    syn::Type::Slice(s) => Some(s),
-                    _ => None,
+                if let syn::Type::Slice(s) = ty_ref.elem.as_ref() {
+                    Some(s)
+                } else {
+                    None
                 }
-                .and_then(|slice| match slice.elem.as_ref() {
-                    syn::Type::Path(ty) => Some(ty),
-                    _ => None,
+                .and_then(|slice| {
+                    if let syn::Type::Path(ty) = slice.elem.as_ref() {
+                        Some(ty)
+                    } else {
+                        None
+                    }
                 })
             })
         })
@@ -505,17 +503,23 @@ fn parse_world_from_args(sig: &syn::Signature) -> syn::Result<&syn::TypePath> {
             syn::FnArg::Typed(a) => Ok(a),
             syn::FnArg::Receiver(_) => Err(first_arg.span()),
         })
-        .and_then(|typed_arg| match typed_arg.ty.as_ref() {
-            syn::Type::Reference(r) => Ok(r),
-            _ => Err(typed_arg.span()),
+        .and_then(|typed_arg| {
+            if let syn::Type::Reference(r) = typed_arg.ty.as_ref() {
+                Ok(r)
+            } else {
+                Err(typed_arg.span())
+            }
         })
         .and_then(|world_ref| match world_ref.mutability {
             Some(_) => Ok(world_ref),
             None => Err(world_ref.span()),
         })
-        .and_then(|world_mut_ref| match world_mut_ref.elem.as_ref() {
-            syn::Type::Path(p) => Ok(p),
-            _ => Err(world_mut_ref.span()),
+        .and_then(|world_mut_ref| {
+            if let syn::Type::Path(p) = world_mut_ref.elem.as_ref() {
+                Ok(p)
+            } else {
+                Err(world_mut_ref.span())
+            }
         })
         .map_err(|span| {
             syn::Error::new(
@@ -530,8 +534,9 @@ fn parse_world_from_args(sig: &syn::Signature) -> syn::Result<&syn::TypePath> {
 /// [`syn::Lit`]: enum@syn::Lit
 /// [`syn::LitStr`]: struct@syn::LitStr
 fn to_string_literal(l: syn::Lit) -> syn::Result<syn::LitStr> {
-    match l {
-        syn::Lit::Str(str) => Ok(str),
-        _ => Err(syn::Error::new(l.span(), "Expected string literal")),
+    if let syn::Lit::Str(str) = l {
+        Ok(str)
+    } else {
+        Err(syn::Error::new(l.span(), "Expected string literal"))
     }
 }

codegen/src/lib.rs

@@ -14,6 +14,7 @@
 )]
 #![doc = include_str!("../README.md")]
 #![deny(
+    macro_use_extern_crate,
     nonstandard_style,
     rust_2018_idioms,
     rustdoc::broken_intra_doc_links,
@@ -23,15 +24,73 @@
 )]
 #![forbid(non_ascii_idents, unsafe_code)]
 #![warn(
-    deprecated_in_future,
+    clippy::as_conversions,
+    clippy::branches_sharing_code,
+    clippy::clone_on_ref_ptr,
+    clippy::dbg_macro,
+    clippy::debug_assert_with_mut_call,
+    clippy::decimal_literal_representation,
+    clippy::else_if_without_else,
+    clippy::empty_line_after_outer_attr,
+    clippy::exit,
+    clippy::expect_used,
+    clippy::fallible_impl_from,
+    clippy::float_cmp_const,
+    clippy::fn_to_numeric_cast,
+    clippy::get_unwrap,
+    clippy::if_then_some_else_none,
+    clippy::imprecise_flops,
+    clippy::let_underscore_must_use,
+    clippy::lossy_float_literal,
+    clippy::map_err_ignore,
+    clippy::mem_forget,
+    clippy::missing_const_for_fn,
+    clippy::missing_docs_in_private_items,
+    clippy::multiple_inherent_impl,
+    clippy::mutex_integer,
+    clippy::nonstandard_macro_braces,
+    clippy::option_if_let_else,
+    clippy::panic_in_result_fn,
+    clippy::pedantic,
+    clippy::print_stderr,
+    clippy::print_stdout,
+    clippy::rc_buffer,
+    clippy::rc_mutex,
+    clippy::rest_pat_in_fully_bound_structs,
+    clippy::shadow_unrelated,
+    clippy::str_to_string,
+    clippy::string_add,
+    clippy::string_lit_as_bytes,
+    clippy::string_to_string,
+    clippy::suboptimal_flops,
+    clippy::suspicious_operation_groupings,
+    clippy::todo,
+    clippy::trivial_regex,
+    clippy::unimplemented,
+    clippy::unnecessary_self_imports,
+    clippy::unneeded_field_pattern,
+    clippy::unwrap_in_result,
+    clippy::unwrap_used,
+    clippy::use_debug,
+    clippy::use_self,
+    clippy::useless_let_if_seq,
+    clippy::wildcard_enum_match_arm,
+    future_incompatible,
+    meta_variable_misuse,
     missing_copy_implementations,
     missing_debug_implementations,
     missing_docs,
+    noop_method_call,
+    semicolon_in_expressions_from_macros,
     unreachable_pub,
+    unused_crate_dependencies,
+    unused_extern_crates,
     unused_import_braces,
     unused_labels,
+    unused_lifetimes,
     unused_qualifications,
-    unused_results
+    unused_results,
+    variant_size_differences
 )]
 
 mod attribute;

src/cucumber.rs

@@ -49,10 +49,23 @@ use crate::{
 /// [`WorldInit::cucumber()`]: crate::WorldInit::cucumber()
 /// [`WorldInit::run()`]: crate::WorldInit::run()
 pub struct Cucumber<W, P, I, R, Wr> {
+    /// [`Parser`] sourcing [`Feature`]s for execution.
+    ///
+    /// [`Feature`]: gherkin::Feature
     parser: P,
+
+    /// [`Runner`] executing [`Scenario`]s and producing [`event`]s.
+    ///
+    /// [`Scenario`]: gherkin::Scenario
     runner: R,
+
+    /// [`Writer`] outputting [`event`]s to some output.
     writer: Wr,
+
+    /// Type of the [`World`] this [`Cucumber`] run on.
     _world: PhantomData<W>,
+
+    /// Type of the input consumed by [`Cucumber::parser`].
     _parser_input: PhantomData<I>,
 }
 
@@ -62,7 +75,7 @@ impl<W> Cucumber<W, (), (), (), ()> {
     /// Use [`Cucumber::with_parser()`], [`Cucumber::with_runner()`] and
     /// [`Cucumber::with_writer()`] to be able to [`Cucumber::run()`] it.
     #[must_use]
-    pub fn custom() -> Self {
+    pub const fn custom() -> Self {
         Self {
             parser: (),
             runner: (),

src/event.rs

@@ -51,7 +51,7 @@ impl<World> Clone for Cucumber<World> {
     fn clone(&self) -> Self {
         match self {
             Self::Started => Self::Started,
-            Self::Feature(f, ev) => Self::Feature(f.clone(), ev.clone()),
+            Self::Feature(f, ev) => Self::Feature(Arc::clone(f), ev.clone()),
             Self::Finished => Self::Finished,
         }
     }
@@ -144,8 +144,8 @@ impl<World> Clone for Feature<World> {
     fn clone(&self) -> Self {
         match self {
             Self::Started => Self::Started,
-            Self::Rule(r, ev) => Self::Rule(r.clone(), ev.clone()),
-            Self::Scenario(sc, ev) => Self::Scenario(sc.clone(), ev.clone()),
+            Self::Rule(r, ev) => Self::Rule(Arc::clone(r), ev.clone()),
+            Self::Scenario(s, ev) => Self::Scenario(Arc::clone(s), ev.clone()),
             Self::Finished => Self::Finished,
         }
     }
@@ -176,7 +176,7 @@ impl<World> Clone for Rule<World> {
     fn clone(&self) -> Self {
         match self {
             Self::Started => Self::Started,
-            Self::Scenario(sc, ev) => Self::Scenario(sc.clone(), ev.clone()),
+            Self::Scenario(s, ev) => Self::Scenario(Arc::clone(s), ev.clone()),
             Self::Finished => Self::Finished,
         }
     }
@@ -299,7 +299,7 @@ impl<World> Clone for Hook<World> {
         match self {
             Self::Started => Self::Started,
             Self::Passed => Self::Passed,
-            Self::Failed(w, i) => Self::Failed(w.clone(), i.clone()),
+            Self::Failed(w, i) => Self::Failed(w.clone(), Arc::clone(i)),
         }
     }
 }
@@ -339,9 +339,9 @@ impl<World> Clone for Scenario<World> {
             Self::Started => Self::Started,
             Self::Hook(ty, ev) => Self::Hook(*ty, ev.clone()),
             Self::Background(bg, ev) => {
-                Self::Background(bg.clone(), ev.clone())
+                Self::Background(Arc::clone(bg), ev.clone())
             }
-            Self::Step(st, ev) => Self::Step(st.clone(), ev.clone()),
+            Self::Step(st, ev) => Self::Step(Arc::clone(st), ev.clone()),
             Self::Finished => Self::Finished,
         }
     }
@@ -352,15 +352,15 @@ impl<World> Scenario<World> {
     ///
     /// [`Scenario`]: gherkin::Scenario
     #[must_use]
-    pub fn hook_started(which: HookType) -> Self {
+    pub const fn hook_started(which: HookType) -> Self {
         Self::Hook(which, Hook::Started)
     }
 
     /// Constructs an event of a passed [`Scenario`] hook.
     ///
     /// [`Scenario`]: gherkin::Scenario
     #[must_use]
-    pub fn hook_passed(which: HookType) -> Self {
+    pub const fn hook_passed(which: HookType) -> Self {
         Self::Hook(which, Hook::Passed)
     }