diff --git a/checkoutlist.md b/checkoutlist.md
index 7600153..716030b 100644
--- a/checkoutlist.md
+++ b/checkoutlist.md
@@ -2,6 +2,7 @@
 
 - [ ] Update rustup
 - [ ] Update dependency `cargo upgrade`
+- [ ] Run `cargo clippy`
 - [ ] Run all test
   - [ ] Stable: `RSTEST_TEST_CHANNEL=stable; cargo +${RSTEST_TEST_CHANNEL} test`
   - [ ] Beta: `RSTEST_TEST_CHANNEL=beta; cargo +${RSTEST_TEST_CHANNEL} test`
diff --git a/src/error.rs b/src/error.rs
index 3da9ae9..2766d39 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -89,9 +89,9 @@ impl From<Vec<syn::Error>> for ErrorsVec {
     }
 }
 
-impl Into<Vec<syn::Error>> for ErrorsVec {
-    fn into(self) -> Vec<syn::Error> {
-        self.0
+impl From<ErrorsVec> for Vec<syn::Error> {
+    fn from(v: ErrorsVec) -> Self {
+        v.0
     }
 }
 
@@ -101,10 +101,10 @@ impl quote::ToTokens for ErrorsVec {
     }
 }
 
-impl Into<proc_macro::TokenStream> for ErrorsVec {
-    fn into(self) -> proc_macro::TokenStream {
+impl From<ErrorsVec> for proc_macro::TokenStream {
+    fn from(v: ErrorsVec) -> Self {
         use quote::ToTokens;
-        self.into_token_stream().into()
+        v.into_token_stream().into()
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 8209adc..e10244b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -515,7 +515,7 @@ pub fn fixture(
     }
 
     if errors.is_empty() {
-        render::fixture(fixture, info).into()
+        render::fixture(fixture, info)
     } else {
         errors
     }
@@ -578,7 +578,7 @@ pub fn fixture(
 /// ```
 ///
 /// If you want to use long and descriptive names for your fixture but prefer to use
-/// shorter names inside your tests you use rename feature described in 
+/// shorter names inside your tests you use rename feature described in
 /// [fixture rename](attr.fixture.html#rename):
 ///
 /// ```
diff --git a/src/parse/expressions.rs b/src/parse/expressions.rs
index 269225a..152662b 100644
--- a/src/parse/expressions.rs
+++ b/src/parse/expressions.rs
@@ -21,8 +21,8 @@ impl Parse for Expressions {
     }
 }
 
-impl Into<Vec<Expr>> for Expressions {
-    fn into(self) -> Vec<Expr> {
-        self.0
+impl From<Expressions> for Vec<Expr> {
+    fn from(expressions: Expressions) -> Self {
+        expressions.0
     }
-}
+}
\ No newline at end of file
diff --git a/src/parse/fixture.rs b/src/parse/fixture.rs
index 4ee3a5b..84c4941 100644
--- a/src/parse/fixture.rs
+++ b/src/parse/fixture.rs
@@ -174,7 +174,7 @@ impl FixtureData {
 
     pub(crate) fn values(&self) -> impl Iterator<Item = &ArgumentValue> {
         self.items.iter().filter_map(|f| match f {
-            FixtureItem::ArgumentValue(ref value) => Some(value),
+            FixtureItem::ArgumentValue(ref value) => Some(value.as_ref()),
             _ => None,
         })
     }
@@ -207,7 +207,7 @@ impl ArgumentValue {
 #[derive(PartialEq, Debug)]
 pub(crate) enum FixtureItem {
     Fixture(Fixture),
-    ArgumentValue(ArgumentValue),
+    ArgumentValue(Box<ArgumentValue>),
 }
 
 impl From<Fixture> for FixtureItem {
@@ -230,7 +230,7 @@ impl RefIdent for FixtureItem {
     fn ident(&self) -> &Ident {
         match self {
             FixtureItem::Fixture(Fixture { ref name, .. }) => name,
-            FixtureItem::ArgumentValue(ArgumentValue { ref name, .. }) => name,
+            FixtureItem::ArgumentValue(ref av) => &av.name,
         }
     }
 }
@@ -243,7 +243,7 @@ impl ToTokens for FixtureItem {
 
 impl From<ArgumentValue> for FixtureItem {
     fn from(av: ArgumentValue) -> Self {
-        FixtureItem::ArgumentValue(av)
+        FixtureItem::ArgumentValue(Box::new(av))
     }
 }
 
@@ -273,14 +273,14 @@ impl FixtureModifiers {
     pub(crate) fn set_default_return_type(&mut self, return_type: syn::Type) {
         self.inner.attributes.push(Attribute::Type(
             format_ident!("{}", Self::DEFAULT_RET_ATTR),
-            return_type,
+            Box::new(return_type),
         ))
     }
 
     pub(crate) fn set_partial_return_type(&mut self, id: usize, return_type: syn::Type) {
         self.inner.attributes.push(Attribute::Type(
             format_ident!("{}{}", Self::PARTIAL_RET_ATTR, id),
-            return_type,
+            Box::new(return_type),
         ))
     }
 
diff --git a/src/parse/future.rs b/src/parse/future.rs
index a3ebf50..08a6340 100644
--- a/src/parse/future.rs
+++ b/src/parse/future.rs
@@ -61,7 +61,7 @@ impl VisitMut for ReplaceFutureAttribute {
                     self.errors.extend(futures.iter().skip(1).map(|attr| {
                         syn::Error::new_spanned(
                             attr.into_token_stream(),
-                            format!("Cannot use #[future] more than once."),
+                            "Cannot use #[future] more than once.".to_owned(),
                         )
                     }));
                     return;
@@ -73,7 +73,7 @@ impl VisitMut for ReplaceFutureAttribute {
                     | TraitObject(_) | Verbatim(_) => {
                         self.errors.push(syn::Error::new_spanned(
                             ty.into_token_stream(),
-                            format!("This type cannot used to generete impl Future."),
+                            "This type cannot used to generete impl Future.".to_owned(),
                         ));
                         return;
                     }
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index 44d9a77..c950af4 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -57,7 +57,7 @@ impl Parse for Attributes {
 pub(crate) enum Attribute {
     Attr(Ident),
     Tagged(Ident, Vec<Ident>),
-    Type(Ident, syn::Type),
+    Type(Ident, Box<syn::Type>),
 }
 
 impl Parse for Attribute {
@@ -96,11 +96,11 @@ where
             if input_tokens.is_empty() || input_tokens.peek(Token![::]) {
                 Ok(None)
             } else {
-                T::parse(input_tokens).map(|inner| Some(inner))
+                T::parse(input_tokens).map(Some)
             }
         })?
         .into_iter()
-        .filter_map(|it| it)
+        .flatten()
         .collect(),
     )
 }
@@ -190,10 +190,10 @@ pub(crate) fn extract_fixtures(item_fn: &mut ItemFn) -> Result<Vec<Fixture>, Err
     let mut fixtures_extractor = FixturesFunctionExtractor::default();
     fixtures_extractor.visit_item_fn_mut(item_fn);
 
-    if fixtures_extractor.1.len() > 0 {
-        Err(fixtures_extractor.1.into())
-    } else {
+    if fixtures_extractor.1.is_empty() {
         Ok(fixtures_extractor.0)
+    } else {
+        Err(fixtures_extractor.1.into())
     }
 }
 
@@ -201,10 +201,10 @@ pub(crate) fn extract_defaults(item_fn: &mut ItemFn) -> Result<Vec<ArgumentValue
     let mut defaults_extractor = DefaultsFunctionExtractor::default();
     defaults_extractor.visit_item_fn_mut(item_fn);
 
-    if defaults_extractor.1.len() > 0 {
-        Err(defaults_extractor.1.into())
-    } else {
+    if defaults_extractor.1.is_empty() {
         Ok(defaults_extractor.0)
+    } else {
+        Err(defaults_extractor.1.into())
     }
 }
 
@@ -277,7 +277,7 @@ impl VisitMut for DefaultTypeFunctionExtractor {
         let mut defaults = defaults.into_iter();
         let mut data = None;
         let mut errors = ErrorsVec::default();
-        match defaults.nth(0).map(|def| def.parse_args::<syn::Type>()) {
+        match defaults.next().map(|def| def.parse_args::<syn::Type>()) {
             Some(Ok(t)) => data = Some(t),
             Some(Err(e)) => errors.push(e),
             None => {}
@@ -376,10 +376,10 @@ pub(crate) fn extract_case_args(item_fn: &mut ItemFn) -> Result<Vec<Ident>, Erro
     let mut case_args_extractor = CaseArgsFunctionExtractor::default();
     case_args_extractor.visit_item_fn_mut(item_fn);
 
-    if case_args_extractor.1.len() > 0 {
-        Err(case_args_extractor.1.into())
-    } else {
+    if case_args_extractor.1.is_empty() {
         Ok(case_args_extractor.0)
+    } else {
+        Err(case_args_extractor.1.into())
     }
 }
 
@@ -419,10 +419,10 @@ pub(crate) fn extract_cases(item_fn: &mut ItemFn) -> Result<Vec<TestCase>, Error
     let mut cases_extractor = CasesFunctionExtractor::default();
     cases_extractor.visit_item_fn_mut(item_fn);
 
-    if cases_extractor.1.len() > 0 {
-        Err(cases_extractor.1.into())
-    } else {
+    if cases_extractor.1.is_empty() {
         Ok(cases_extractor.0)
+    } else {
+        Err(cases_extractor.1.into())
     }
 }
 
@@ -457,10 +457,10 @@ pub(crate) fn extract_value_list(item_fn: &mut ItemFn) -> Result<Vec<ValueList>,
     let mut vlist_extractor = ValueListFunctionExtractor::default();
     vlist_extractor.visit_item_fn_mut(item_fn);
 
-    if vlist_extractor.1.len() > 0 {
-        Err(vlist_extractor.1.into())
-    } else {
+    if vlist_extractor.1.is_empty() {
         Ok(vlist_extractor.0)
+    } else {
+        Err(vlist_extractor.1.into())
     }
 }
 
@@ -483,13 +483,12 @@ impl ExcludedTraceAttributesFunctionExtractor {
             Ok(_) => self.0 = Err(errors),
             Err(err) => err.append(&mut errors),
         }
-        .into()
     }
 
     fn update_excluded(&mut self, value: Ident) {
-        self.0.iter_mut().next().map(|inner| {
+        if let Some(inner) = self.0.iter_mut().next() {
             inner.push(value);
-        });
+        }
     }
 }
 
diff --git a/src/parse/rstest.rs b/src/parse/rstest.rs
index 40bb78d..7ad00ea 100644
--- a/src/parse/rstest.rs
+++ b/src/parse/rstest.rs
@@ -212,10 +212,7 @@ impl RsTestAttributes {
 
     pub(crate) fn trace_me(&self, ident: &Ident) -> bool {
         if self.should_trace() {
-            self.iter()
-                .filter(|&m| Self::is_notrace(ident, m))
-                .next()
-                .is_none()
+            !self.iter().any(|m| Self::is_notrace(ident, m))
         } else {
             false
         }
@@ -224,14 +221,14 @@ impl RsTestAttributes {
     fn is_notrace(ident: &Ident, m: &Attribute) -> bool {
         match m {
             Attribute::Tagged(i, args) if i == Self::NOTRACE_VARIABLE_ATTR => {
-                args.iter().find(|&a| a == ident).is_some()
+                args.iter().any(|a| a == ident)
             }
             _ => false,
         }
     }
 
     pub(crate) fn should_trace(&self) -> bool {
-        self.iter().filter(|&m| Self::is_trace(m)).next().is_some()
+        self.iter().any(Self::is_trace)
     }
 
     pub(crate) fn add_trace(&mut self, trace: Ident) {
@@ -249,10 +246,7 @@ impl RsTestAttributes {
     }
 
     fn is_trace(m: &Attribute) -> bool {
-        match m {
-            Attribute::Attr(i) if i == Self::TRACE_VARIABLE_ATTR => true,
-            _ => false,
-        }
+        matches!(m, Attribute::Attr(i) if i == Self::TRACE_VARIABLE_ATTR)
     }
 }
 
@@ -362,7 +356,7 @@ mod test {
                         fixture("short", &["42", r#""other""#])
                             .with_resolve("long_fixture_name")
                             .into(),
-                        fixture("s", &[]).with_resolve("simple").into()
+                        fixture("s", &[]).with_resolve("simple").into(),
                     ]
                     .into(),
                     ..Default::default()
@@ -374,7 +368,6 @@ mod test {
 
                 assert_eq!(expected, data);
             }
-            
 
             #[test]
             fn defined_via_with_attributes() {
@@ -493,10 +486,7 @@ mod test {
             let data = info.data;
             let fixtures = data.fixtures().cloned().collect::<Vec<_>>();
 
-            assert_eq!(
-                vec![fixture("my_fixture", &["42", r#""foo""#])],
-                fixtures
-            );
+            assert_eq!(vec![fixture("my_fixture", &["42", r#""foo""#])], fixtures);
             assert_eq!(
                 to_strs!(vec!["arg1", "arg2", "arg3"]),
                 data.case_args()
diff --git a/src/parse/vlist.rs b/src/parse/vlist.rs
index 03f9646..43a5aab 100644
--- a/src/parse/vlist.rs
+++ b/src/parse/vlist.rs
@@ -27,7 +27,7 @@ impl Parse for ValueList {
             arg,
             values: values.take(),
         };
-        if ret.values.len() == 0 {
+        if ret.values.is_empty() {
             Err(syn::Error::new(
                 paren.span,
                 "Values list should not be empty",
diff --git a/src/render/fixture.rs b/src/render/fixture.rs
index 81f934c..af7d417 100644
--- a/src/render/fixture.rs
+++ b/src/render/fixture.rs
@@ -8,7 +8,7 @@ use crate::resolver::{self, Resolver};
 use crate::utils::{fn_args, fn_args_idents};
 use crate::{parse::fixture::FixtureInfo, utils::generics_clean_up};
 
-pub(crate) fn render<'a>(fixture: ItemFn, info: FixtureInfo) -> TokenStream {
+pub(crate) fn render(fixture: ItemFn, info: FixtureInfo) -> TokenStream {
     let name = &fixture.sig.ident;
     let asyncness = &fixture.sig.asyncness.clone();
     let vargs = fn_args_idents(&fixture).cloned().collect::<Vec<_>>();
@@ -19,7 +19,7 @@ pub(crate) fn render<'a>(fixture: ItemFn, info: FixtureInfo) -> TokenStream {
     let default_output = info
         .attributes
         .extract_default_type()
-        .unwrap_or(fixture.sig.output.clone());
+        .unwrap_or_else(|| fixture.sig.output.clone());
     let default_generics =
         generics_clean_up(&fixture.sig.generics, std::iter::empty(), &default_output);
     let default_where_clause = &default_generics.where_clause;
@@ -75,7 +75,7 @@ fn render_partial_impl(
     let output = info
         .attributes
         .extract_partial_type(n)
-        .unwrap_or(fixture.sig.output.clone());
+        .unwrap_or_else(|| fixture.sig.output.clone());
 
     let generics = generics_clean_up(&fixture.sig.generics, fn_args(fixture).take(n), &output);
     let where_clause = &generics.where_clause;
diff --git a/src/render/inject.rs b/src/render/inject.rs
index e286a5c..55fd714 100644
--- a/src/render/inject.rs
+++ b/src/render/inject.rs
@@ -54,7 +54,6 @@ where
         let mut fixture = self
             .resolver
             .resolve(&fixture_name)
-            .map(|e| e.clone())
             .unwrap_or_else(|| default_fixture_resolve(&fixture_name));
 
         if fixture.is_literal() && self.type_can_be_get_from_literal_str(arg_type) {
@@ -68,7 +67,7 @@ where
 
     fn fixture_name<'a>(&self, ident: &'a Ident) -> Cow<'a, Ident> {
         let id_str = ident.to_string();
-        if id_str.starts_with("_") && !id_str.starts_with("__") {
+        if id_str.starts_with('_') && !id_str.starts_with("__") {
             Cow::Owned(Ident::new(&id_str[1..], ident.span()))
         } else {
             Cow::Borrowed(ident)
diff --git a/src/render/mod.rs b/src/render/mod.rs
index 60b97e6..3a4cdc9 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -31,8 +31,8 @@ pub(crate) mod inject;
 pub(crate) fn single(mut test: ItemFn, info: RsTestInfo) -> TokenStream {
     let resolver = resolver::fixtures::get(info.data.fixtures());
     let args = test.sig.inputs.iter().cloned().collect::<Vec<_>>();
-    let attrs = std::mem::replace(&mut test.attrs, Default::default());
-    let asyncness = test.sig.asyncness.clone();
+    let attrs = std::mem::take(&mut test.attrs);
+    let asyncness = test.sig.asyncness;
     let generic_types = test
         .sig
         .generics
@@ -111,13 +111,13 @@ fn _matrix_recursive<'a>(
     attrs: &'a [syn::Attribute],
     attributes: &RsTestAttributes,
 ) -> TokenStream {
-    if list_values.len() == 0 {
+    if list_values.is_empty() {
         return Default::default();
     }
     let vlist = list_values[0];
     let list_values = &list_values[1..];
 
-    if list_values.len() == 0 {
+    if list_values.is_empty() {
         vlist.render(test, resolver, attrs, attributes)
     } else {
         let span = test.sig.ident.span();
@@ -184,10 +184,12 @@ fn render_exec_call(fn_path: Path, args: &[Ident], is_async: bool) -> TokenStrea
 /// * `testfn_name` - The name of test function to call
 /// * `args` - The arguments of the test function
 /// * `attrs` - The expected test attributes
-/// * `output` - The expected test return type  
+/// * `output` - The expected test return type
+/// * `asyncness` - The `async` fn token
 /// * `test_impl` - If you want embed test function (should be the one called by `testfn_name`)
 /// * `resolver` - The resolver used to resolve injected values
 /// * `attributes` - Test attributes to select test behaviour
+/// * `generic_types` - The genrics type used in signature
 ///
 fn single_test_case<'a>(
     name: &Ident,
@@ -204,7 +206,7 @@ fn single_test_case<'a>(
     let (attrs, trace_me): (Vec<_>, Vec<_>) =
         attrs.iter().cloned().partition(|a| !attr_is(a, "trace"));
     let mut attributes = attributes.clone();
-    if trace_me.len() > 0 {
+    if !trace_me.is_empty() {
         attributes.add_trace(format_ident!("trace"));
     }
     let inject = inject::resolve_aruments(args.iter(), &resolver, generic_types);
@@ -247,11 +249,11 @@ fn trace_arguments<'a>(
     let mut statements = args
         .filter(|&arg| attributes.trace_me(arg))
         .map(|arg| {
-            parse_quote! {
+            let s: Stmt = parse_quote! {
                 println!("{} = {:?}", stringify!(#arg), #arg);
-            }
+            };
+            s
         })
-        .map(|stmt: Stmt| stmt)
         .peekable();
     if statements.peek().is_some() {
         Some(quote! {
@@ -282,7 +284,7 @@ impl<'a> TestCaseRender<'a> {
         let args = testfn.sig.inputs.iter().cloned().collect::<Vec<_>>();
         let mut attrs = testfn.attrs.clone();
         attrs.extend(self.attrs.iter().cloned());
-        let asyncness = testfn.sig.asyncness.clone();
+        let asyncness = testfn.sig.asyncness;
         let generic_types = testfn
             .sig
             .generics
diff --git a/src/resolver.rs b/src/resolver.rs
index 9cdf5cc..8371fa8 100644
--- a/src/resolver.rs
+++ b/src/resolver.rs
@@ -17,7 +17,7 @@ pub(crate) mod fixtures {
 
     pub(crate) fn get<'a>(fixtures: impl Iterator<Item = &'a Fixture>) -> impl Resolver + 'a {
         fixtures
-            .map(|f| (f.name.to_string(), extract_resolve_expression(f).into()))
+            .map(|f| (f.name.to_string(), extract_resolve_expression(f)))
             .collect::<HashMap<_, Expr>>()
     }
 
@@ -138,7 +138,7 @@ impl<R: Resolver + ?Sized> Resolver for Box<R> {
 
 impl Resolver for (String, Expr) {
     fn resolve(&self, ident: &Ident) -> Option<Cow<Expr>> {
-        if self.0 == ident.to_string() {
+        if *ident == self.0 {
             Some(Cow::Borrowed(&self.1))
         } else {
             None
diff --git a/src/utils.rs b/src/utils.rs
index 7d1462b..f6f3ca7 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -15,7 +15,7 @@ pub(crate) fn fn_args_idents(test: &ItemFn) -> impl Iterator<Item = &Ident> {
 /// Return if function declaration has an ident
 ///
 pub(crate) fn fn_args_has_ident(fn_decl: &ItemFn, ident: &Ident) -> bool {
-    fn_args_idents(fn_decl).find(|&id| id == ident).is_some()
+    fn_args_idents(fn_decl).any(|id| id == ident)
 }
 
 /// Return an iterator over fn arguments.
@@ -25,11 +25,11 @@ pub(crate) fn fn_args(item_fn: &ItemFn) -> impl Iterator<Item = &FnArg> {
 }
 
 pub(crate) fn attr_ends_with(attr: &Attribute, segment: &syn::PathSegment) -> bool {
-    &attr.path.segments.iter().last() == &Some(segment)
+    attr.path.segments.iter().last() == Some(segment)
 }
 
 pub(crate) fn attr_starts_with(attr: &Attribute, segment: &syn::PathSegment) -> bool {
-    &attr.path.segments.iter().nth(0) == &Some(segment)
+    attr.path.segments.iter().next() == Some(segment)
 }
 
 pub(crate) fn attr_is(attr: &Attribute, name: &str) -> bool {
@@ -38,7 +38,7 @@ pub(crate) fn attr_is(attr: &Attribute, name: &str) -> bool {
 
 pub(crate) fn attr_in(attr: &Attribute, names: &[&str]) -> bool {
     names
-        .into_iter()
+        .iter()
         .any(|name| attr.path.is_ident(&format_ident!("{}", name)))
 }
 
@@ -48,13 +48,13 @@ pub(crate) trait IsLiteralExpression {
 
 impl<E: AsRef<Expr>> IsLiteralExpression for E {
     fn is_literal(&self) -> bool {
-        match self.as_ref() {
-            &Expr::Lit(syn::ExprLit { ref lit, .. }) => match lit {
-                syn::Lit::Str(_) => true,
-                _ => false,
-            },
-            _ => false,
-        }
+        matches!(
+            self.as_ref(),
+            Expr::Lit(syn::ExprLit {
+                lit: syn::Lit::Str(_),
+                ..
+            })
+        )
     }
 }
 
@@ -251,7 +251,7 @@ fn first_type_path_segment_ident(t: &Type) -> Option<&Ident> {
             .path
             .segments
             .iter()
-            .nth(0)
+            .next()
             .and_then(|ps| match ps.arguments {
                 syn::PathArguments::None => Some(&ps.ident),
                 _ => None,
@@ -263,7 +263,7 @@ fn first_type_path_segment_ident(t: &Type) -> Option<&Ident> {
 pub(crate) fn fn_arg_mutability(arg: &FnArg) -> Option<syn::token::Mut> {
     match arg {
         FnArg::Typed(syn::PatType { pat, .. }) => match pat.as_ref() {
-            syn::Pat::Ident(syn::PatIdent { mutability, .. }) => mutability.clone(),
+            syn::Pat::Ident(syn::PatIdent { mutability, .. }) => *mutability,
             _ => None,
         },
         _ => None,