Fix clippy lints; add CI (#37)

.github/workflows/test-suite.yml

@@ -19,6 +19,15 @@ jobs:
       run: rustup update stable
     - name: Check formatting with cargo fmt
       run: cargo fmt --all -- --check
+  clippy:
+    name: clippy
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Get latest version of stable Rust
+      run: rustup update stable
+    - name: Check formatting with cargo fmt
+      run: cargo clippy --tests --release
   test:
     name: test
     runs-on: ubuntu-latest

src/attributes.rs

@@ -13,7 +13,7 @@ pub struct NestedMetaList {
 impl FromMeta for NestedMetaList {
     fn from_list(items: &[NestedMeta]) -> Result<Self, Error> {
         Ok(Self {
-            metas: items.iter().cloned().collect(),
+            metas: items.to_vec(),
         })
     }
 }

src/from.rs

@@ -19,6 +19,7 @@ pub fn generate_from_variant_trait_impl(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn generate_from_variant_trait_impl_for_ref(
     ref_ty_name: &Ident,
     ref_ty_lifetime: &Lifetime,

src/lib.rs

@@ -229,10 +229,11 @@ pub fn superstruct(args: TokenStream, input: TokenStream) -> TokenStream {
             .attrs
             .iter()
             .filter(|attr| is_superstruct_attr(attr))
-            .find_map(|attr| {
+            .map(|attr| {
                 let meta = attr.parse_meta().unwrap();
-                Some(FieldOpts::from_meta(&meta).unwrap())
+                FieldOpts::from_meta(&meta).unwrap()
             })
+            .next()
             .unwrap_or_default();
 
         // Drop the field-level superstruct attributes
@@ -467,25 +468,23 @@ pub fn superstruct(args: TokenStream, input: TokenStream) -> TokenStream {
     let mut inner_enum_names = vec![];
 
     // Generate inner enums if necessary.
-    for meta_variant in meta_variant_names {
-        if let Some(meta_variant) = meta_variant {
-            let inner_enum_name = format_ident!("{}{}", type_name, meta_variant);
-            inner_enum_names.push(inner_enum_name.clone());
-            let inner_struct_names = variant_names
-                .iter()
-                .map(|variant_name| format_ident!("{}{}", inner_enum_name, variant_name))
-                .collect_vec();
-            generate_wrapper_enums(
-                &inner_enum_name,
-                &item,
-                &opts,
-                &mut output_items,
-                variant_names,
-                &inner_struct_names,
-                &fields,
-                false,
-            );
-        }
+    for meta_variant in meta_variant_names.iter().flatten() {
+        let inner_enum_name = format_ident!("{}{}", type_name, meta_variant);
+        inner_enum_names.push(inner_enum_name.clone());
+        let inner_struct_names = variant_names
+            .iter()
+            .map(|variant_name| format_ident!("{}{}", inner_enum_name, variant_name))
+            .collect_vec();
+        generate_wrapper_enums(
+            &inner_enum_name,
+            &item,
+            &opts,
+            &mut output_items,
+            variant_names,
+            &inner_struct_names,
+            &fields,
+            false,
+        );
     }
 
     // Generate outer enum.
@@ -513,11 +512,12 @@ pub fn superstruct(args: TokenStream, input: TokenStream) -> TokenStream {
     TokenStream::from_iter(output_items)
 }
 
+#[allow(clippy::too_many_arguments)]
 fn generate_wrapper_enums(
     type_name: &Ident,
     item: &ItemStruct,
     opts: &StructOpts,
-    mut output_items: &mut Vec<TokenStream>,
+    output_items: &mut Vec<TokenStream>,
     variant_names: &[Ident],
     struct_names: &[Ident],
     fields: &[FieldData],
@@ -627,13 +627,13 @@ fn generate_wrapper_enums(
     let getters = fields
         .iter()
         .filter(|f| f.is_common())
-        .map(|field_data| make_field_getter(type_name, &variant_names, &field_data, None, is_meta));
+        .map(|field_data| make_field_getter(type_name, variant_names, field_data, None, is_meta));
 
     let mut_getters = fields
         .iter()
         .filter(|f| f.is_common() && !f.getter_opts.no_mut)
         .map(|field_data| {
-            make_mut_field_getter(type_name, &variant_names, &field_data, None, is_meta)
+            make_mut_field_getter(type_name, variant_names, field_data, None, is_meta)
         });
 
     let partial_getters = fields
@@ -645,8 +645,8 @@ fn generate_wrapper_enums(
             let field_variants = &field_data.only_combinations;
             Some(make_partial_getter(
                 type_name,
-                &field_data,
-                &field_variants,
+                field_data,
+                field_variants,
                 &opts.partial_getter_error,
                 *mutability,
                 None,
@@ -713,8 +713,8 @@ fn generate_wrapper_enums(
     let ref_getters = fields.iter().filter(|f| f.is_common()).map(|field_data| {
         make_field_getter(
             &ref_ty_name,
-            &variant_names,
-            &field_data,
+            variant_names,
+            field_data,
             Some(&ref_ty_lifetime),
             is_meta,
         )
@@ -763,8 +763,8 @@ fn generate_wrapper_enums(
         .map(|field_data| {
             make_mut_field_getter(
                 &ref_mut_ty_name,
-                &variant_names,
-                &field_data,
+                variant_names,
+                field_data,
                 Some(&ref_mut_ty_lifetime),
                 is_meta,
             )
@@ -778,8 +778,8 @@ fn generate_wrapper_enums(
             let field_variants = &field_data.only_combinations;
             Some(make_partial_getter(
                 &ref_mut_ty_name,
-                &field_data,
-                &field_variants,
+                field_data,
+                field_variants,
                 &opts.partial_getter_error,
                 true,
                 Some(&ref_mut_ty_lifetime),
@@ -804,14 +804,14 @@ fn generate_wrapper_enums(
     if !opts.no_map_macros && !opts.no_enum {
         let num_generics = decl_generics.params.len();
         generate_all_map_macros(
-            &type_name,
+            type_name,
             &ref_ty_name,
             &ref_mut_ty_name,
             num_generics,
-            &struct_names,
+            struct_names,
             variant_names,
-            &opts,
-            &mut output_items,
+            opts,
+            output_items,
         );
     } else {
         assert!(
@@ -829,7 +829,7 @@ fn generate_wrapper_enums(
     }
 
     // Generate trait implementations.
-    for (variant_name, struct_name) in variant_names.into_iter().zip_eq(struct_names) {
+    for (variant_name, struct_name) in variant_names.iter().zip_eq(struct_names) {
         let from_impl = generate_from_variant_trait_impl(
             type_name,
             impl_generics,
@@ -1107,7 +1107,7 @@ fn is_superstruct_attr(attr: &Attribute) -> bool {
 fn is_attr_with_ident(attr: &Attribute, ident: &str) -> bool {
     attr.path
         .get_ident()
-        .map_or(false, |attr_ident| attr_ident.to_string() == ident)
+        .map_or(false, |attr_ident| *attr_ident == ident)
 }
 
 /// Predicate for determining whether a field should be excluded from a flattened
@@ -1124,7 +1124,7 @@ fn should_skip(
         Override::Inherit => false,
         Override::Explicit(map) => {
             let contains_variant = map.contains_key(variant);
-            let contains_meta_variant = meta_variant.map_or(true, |mv| map.contains_key(&mv));
+            let contains_meta_variant = meta_variant.map_or(true, |mv| map.contains_key(mv));
 
             let variants_exist = variant_names.iter().any(|v| map.contains_key(v));
             let meta_variants_exist = meta_variant_names

src/macros.rs

@@ -15,6 +15,7 @@ pub struct MacroFromType<'a> {
 }
 
 /// Generate all the map macros for the top-level enum, Ref and RefMut.
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn generate_all_map_macros(
     type_name: &Ident,
     ref_type_name: &Ident,
@@ -90,7 +91,7 @@ fn generate_owned_map_macro(
 
     let from_type_name = &from_type.name;
     let from_type_struct_names = from_type.struct_names;
-    let to_type_name = to_type_name.unwrap_or_else(|| from_type_name);
+    let to_type_name = to_type_name.unwrap_or(from_type_name);
     let map_macro_name = generate_map_macro_name(from_type_name, to_type_name);
 
     // Generics we want the compiler to infer.
@@ -130,7 +131,7 @@ fn generate_ref_map_macro(
 
     let from_type_name = &from_type.name;
     let from_type_struct_names = from_type.struct_names;
-    let to_type_name = to_type_name.unwrap_or_else(|| from_type_name);
+    let to_type_name = to_type_name.unwrap_or(from_type_name);
     let map_macro_name = generate_map_macro_name(from_type_name, to_type_name);
 
     // Generics we want the compiler to infer.

tests/basic.rs

@@ -82,7 +82,7 @@ fn serde_deserialise_order() {
     }
 
     let message_str = r#"{"common": "hello", "exclusive": "world"}"#;
-    let message: Message = serde_json::from_str(&message_str).unwrap();
+    let message: Message = serde_json::from_str(message_str).unwrap();
 
     let expected = Message::B(MessageB {
         common: "hello".into(),
@@ -93,6 +93,7 @@ fn serde_deserialise_order() {
 }
 
 #[test]
+#[allow(clippy::non_minimal_cfg)]
 fn cfg_attribute() {
     // Use `all()` as true.
     #[superstruct(variants(A, B), no_map_macros)]