Cargo fix part 2 + cargo clippy for wundergraph_derive

Author: weiznich

wundergraph_derive/src/diagnostic_shim.rs

@@ -74,6 +74,7 @@ impl Diagnostic {
         self.help(msg)
     }
 
+    #[allow(clippy::print_stdout)]
     pub fn emit(self) {
         match self.level {
             Level::Error => panic!("{}", self.message),

wundergraph_derive/src/lib.rs

@@ -1,46 +1,38 @@
 #![recursion_limit = "1024"]
 #![deny(missing_debug_implementations, missing_copy_implementations)]
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", warn(clippy))]
-// Clippy lints
-#![cfg_attr(feature = "cargo-clippy", allow(type_complexity))]
-#![cfg_attr(
-    feature = "cargo-clippy",
-    warn(
-        wrong_pub_self_convention,
-        used_underscore_binding,
-        use_self,
-        unseparated_literal_suffix,
-        unnecessary_unwrap,
-        unimplemented,
-        single_match_else,
-        shadow_unrelated,
-        option_map_unwrap_or_else,
-        option_map_unwrap_or,
-        needless_continue,
-        mutex_integer,
-        needless_borrow,
-        items_after_statements,
-        filter_map,
-        expl_impl_clone_on_copy,
-        else_if_without_else,
-        doc_markdown,
-        default_trait_access,
-        option_unwrap_used,
-        result_unwrap_used,
-        wrong_pub_self_convention,
-        mut_mut,
-        non_ascii_literal,
-        unicode_not_nfc,
-        enum_glob_use,
-        if_not_else,
-        items_after_statements,
-        used_underscore_binding
-    )
+#![warn(
+    clippy::option_unwrap_used,
+    clippy::result_unwrap_used,
+    clippy::print_stdout,
+    clippy::wrong_pub_self_convention,
+    clippy::mut_mut,
+    clippy::non_ascii_literal,
+    clippy::similar_names,
+    clippy::unicode_not_nfc,
+    clippy::enum_glob_use,
+    clippy::if_not_else,
+    clippy::items_after_statements,
+    clippy::used_underscore_binding,
+    clippy::cargo_common_metadata,
+    clippy::dbg_macro,
+    clippy::doc_markdown,
+    clippy::filter_map,
+    clippy::map_flatten,
+    clippy::match_same_arms,
+    clippy::needless_borrow,
+    clippy::needless_pass_by_value,
+    clippy::option_map_unwrap_or,
+    clippy::option_map_unwrap_or_else,
+    clippy::redundant_clone,
+    clippy::result_map_unwrap_or_else,
+    clippy::unnecessary_unwrap,
+    clippy::unseparated_literal_suffix,
+    clippy::wildcard_dependencies
+
 )]
 
 extern crate proc_macro;
-extern crate proc_macro2;
+use proc_macro2;
 #[macro_use]
 extern crate quote;
 #[macro_use]

wundergraph_derive/src/meta.rs

@@ -39,7 +39,7 @@ impl MetaItem {
         attrs
             .iter()
             .filter_map(|a| {
-                let meta = a.parse_meta().unwrap();
+                let meta = a.parse_meta().expect("Failed to parse meta");
                 if meta.name() == "doc" {
                     if let syn::Meta::NameValue(value) = meta {
                         let s = match value.lit {
@@ -91,7 +91,6 @@ impl MetaItem {
         })
     }
 
-
     pub fn expect_ident_value(&self) -> syn::Ident {
         self.ident_value().unwrap_or_else(|e| {
             e.emit();
@@ -110,7 +109,7 @@ impl MetaItem {
                         self.name(),
                     ))
                     .emit();
-                Ok(x.clone())
+                Ok(x)
             }
             _ => Ok(syn::Ident::new(
                 &self.str_value()?,
@@ -132,7 +131,7 @@ impl MetaItem {
         }
     }
 
-    pub fn nested(&self) -> Result<Nested, Diagnostic> {
+    pub fn nested(&self) -> Result<Nested<'_>, Diagnostic> {
         use syn::Meta::*;
 
         match self.meta {
@@ -218,7 +217,6 @@ impl MetaItem {
     }
 }
 
-#[cfg_attr(rustfmt, rustfmt_skip)] // https://github.com/rust-lang-nursery/rustfmt/issues/2392
 pub struct Nested<'a>(syn::punctuated::Iter<'a, syn::NestedMeta>);
 
 impl<'a> Iterator for Nested<'a> {

wundergraph_derive/src/model.rs

@@ -22,9 +22,10 @@ impl Model {
         let flags = MetaItem::with_name(&item.attrs, "wundergraph")
             .unwrap_or_else(|| MetaItem::empty("wundergraph"));
         let docs = MetaItem::get_docs(&item.attrs);
-        let primary_keys = MetaItem::with_name(&item.attrs, "primary_key")
-            .map(|m| m.nested()?.map(|m| m.word()).collect())
-            .unwrap_or_else(|| Ok(vec![syn::Ident::new("id", Span::call_site())]))?;
+        let primary_keys = MetaItem::with_name(&item.attrs, "primary_key").map_or_else(
+            || Ok(vec![syn::Ident::new("id", Span::call_site())]),
+            |m| m.nested()?.map(|m| m.word()).collect(),
+        )?;
         Ok(Self {
             name: item.ident.clone(),
             fields,

wundergraph_derive/src/wundergraph_entity.rs

@@ -1,8 +1,9 @@
 use crate::diagnostic_shim::{Diagnostic, DiagnosticShim};
+use crate::field::Field;
 use crate::model::Model;
+use crate::utils::{inner_of_option_ty, inner_ty_args, is_has_many, wrap_in_dummy_mod};
 use proc_macro2::{Span, TokenStream};
 use syn;
-use crate::utils::{inner_of_option_ty, inner_ty_args, is_has_many, wrap_in_dummy_mod};
 
 pub fn derive(item: &syn::DeriveInput) -> Result<TokenStream, Diagnostic> {
     let model = Model::from_item(item)?;
@@ -124,7 +125,7 @@ fn derive_loading_handler(
     let struct_type = &model.name;
     let (_, ty_generics, _) = item.generics.split_for_impl();
     let table = model.table_type()?;
-    let field_names = model.fields().iter().map(|f| f.graphql_name());
+    let field_names = model.fields().iter().map(Field::graphql_name);
     let field_list = model.fields().iter().map(|f| &f.ty);
     let columns = model.fields().iter().filter_map(|f| {
         if is_has_many(&f.ty) {
@@ -178,17 +179,19 @@ fn derive_loading_handler(
         }
     });
 
-    let type_description = model
-        .docs
-        .as_ref()
-        .map(|d| quote!(std::option::Option::Some(#d)))
-        .unwrap_or_else(|| quote!(std::option::Option::None));
+    let type_description = model.docs.as_ref().map_or_else(
+        || quote!(std::option::Option::None),
+        |d| quote!(std::option::Option::Some(#d)),
+    );
 
-    let filter = model.filter_type().map(|p| quote!(#p)).unwrap_or_else(|| {
-        quote! {
-            wundergraph::filter::filter_helper::FilterWrapper<Self, #backend, __Ctx>
-        }
-    });
+    let filter = model.filter_type().map_or_else(
+        || {
+            quote! {
+                wundergraph::filter::filter_helper::FilterWrapper<Self, #backend, __Ctx>
+            }
+        },
+        |p| quote!(#p),
+    );
 
     let mut generics = item.generics.clone();
     generics

wundergraph_derive/src/wundergraph_filter.rs

@@ -1,9 +1,9 @@
-use crate::diagnostic_shim::{Diagnostic, };
+use crate::diagnostic_shim::Diagnostic;
 use crate::field::Field;
 use crate::model::Model;
-use proc_macro2::{TokenStream};
-use syn;
 use crate::utils::{inner_of_box_ty, inner_of_option_ty, is_box_ty, wrap_in_dummy_mod};
+use proc_macro2::TokenStream;
+use syn;
 
 pub fn derive(item: &syn::DeriveInput) -> Result<TokenStream, Diagnostic> {
     let inner_filter = inner_filter(item)?;
@@ -139,7 +139,7 @@ fn build_from_inner_input_value(model: &Model) -> Result<TokenStream, Diagnostic
             };
         )
     });
-    let fields = model.fields().iter().map(|f| f.rust_name());
+    let fields = model.fields().iter().map(Field::rust_name);
     Ok(quote! {
         #(#build_field)*
 
@@ -165,7 +165,7 @@ fn build_from_look_ahead(model: &Model) -> Result<TokenStream, Diagnostic> {
                 #map_box;
         }
     });
-    let fields = model.fields().iter().map(|f| f.rust_name());
+    let fields = model.fields().iter().map(Field::rust_name);
     Ok(quote! {
         #(#build_field)*
 
@@ -198,7 +198,7 @@ fn build_register_fields(model: &Model) -> Result<TokenStream, Diagnostic> {
             );
         }
     });
-    let fields = model.fields().iter().map(|f| f.graphql_name());
+    let fields = model.fields().iter().map(Field::graphql_name);
     Ok(quote! {
         #(#register_field)*
         vec![#(#fields,)*]

wundergraph_derive/src/wundergraph_value.rs

@@ -1,9 +1,9 @@
 use crate::diagnostic_shim::*;
 use crate::meta::MetaItem;
+use crate::utils::wrap_in_dummy_mod;
 use proc_macro2::{Span, TokenStream};
 use syn;
 use syn::spanned::Spanned;
-use crate::utils::wrap_in_dummy_mod;
 
 pub fn derive(item: &syn::DeriveInput) -> Result<TokenStream, Diagnostic> {
     let filter_value = filter_value(item);
@@ -59,7 +59,7 @@ fn wundergraph_value(item: &syn::DeriveInput) -> Result<TokenStream, Diagnostic>
         .map(|m| m.expect_ident_value())
         .ok_or_else(|| {
             item.span()
-                .error(format!("Missing required option `sql_type`",))
+                .error("Missing required option `sql_type`".to_string())
         })?;
     let item_name = &item.ident;
     let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();