refactor: cleanup and changes to satisfy Clippy

Signed-off-by: Richard Zak <[email protected]>

Author: rjzak

.github/workflows/rust.yml

@@ -11,9 +11,7 @@ env:
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
-
     steps:
     - uses: actions/checkout@v3
     - name: UpdateRust
@@ -22,3 +20,12 @@ jobs:
       run: rustup -V && cargo build --verbose 
     # - name: Run tests
     #  run: cargo test --verbose
+
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: UpdateRust
+        run: rustup update stable
+      - name: Clippy
+        run: cargo clippy --workspace --all-features -- -D warnings

Cargo.toml

@@ -44,6 +44,7 @@ custom_derive = "0.1.7"
 glob = "0.3.0"
 thread_local = "1.1.4"
 tokio = { version = "1.35.1", features = ["full"] , optional = true}
+tracing = "0.1"
 libc = { version = "0.2.137", optional = true }
 async-global-executor = "2.4.1"
 envy = "0.4.2"
@@ -58,7 +59,6 @@ hostname = "0.3"
 nix = "0.23"
 assert_cmd = "2.0.4"
 serial_test = "0.6.0"
-tracing-subscriber = "0.3"
 #packed_simd = { version = "0.3.4", package = "packed_simd_2" } #uncomment if using nightly tool chain and want to run the am_flops example
 
 [workspace]

impl/Cargo.toml

@@ -22,3 +22,6 @@ quote = "1.0.21"
 syn = { version = "2.0.17", features = ["full","extra-traits","fold","visit-mut",] }
 async-trait = "0.1.58"
 futures = "0.3.25"
+
+[dev-dependencies]
+lamellar = "0.7"

impl/src/am_data.rs

@@ -9,7 +9,7 @@ use quote::{quote, ToTokens};
 use syn::parse_macro_input;
 use syn::punctuated::Punctuated;
 
-fn check_attrs(attrs: &Vec<syn::Attribute>) -> (bool, bool, Vec<syn::Attribute>) {
+fn check_attrs(attrs: &[syn::Attribute]) -> (bool, bool, Vec<syn::Attribute>) {
     let mut static_field = false;
     let attrs = attrs
         .iter()
@@ -167,7 +167,7 @@ fn process_fields(
             }
         } else if !t.contains("serde::Serialize")
             && !t.contains("serde::Deserialize")
-            && t.trim().len() > 0
+            && !t.trim().is_empty()
         {
             let temp = quote::format_ident!("{}", t.trim());
             trait_strs
@@ -262,7 +262,7 @@ pub(crate) fn derive_am_data(
             &traits,
             &attrs,
             &vis,
-            &name,
+            name,
             &full_fields,
             &full_ser,
             &full_des,
@@ -276,7 +276,7 @@ pub(crate) fn derive_am_data(
                 &group_traits,
                 &group_attrs,
                 &vis,
-                &name,
+                name,
                 &fields,
                 &static_fields,
                 &lamellar,

impl/src/array_ops.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::type_complexity)]
+
 use proc_macro::TokenStream;
 // use proc_macro_error::abort;
 use proc_macro2::Ident;
@@ -255,7 +257,7 @@ fn gen_array_names(
 ) -> (Ident, Ident, Ident, Ident, Ident, Ident, Ident, Ident) {
     let base = quote::format_ident!(
         "{array_type}_{}_{val_type}_val_{idx_type}_idx",
-        type_to_string(&typeident)
+        type_to_string(typeident)
     );
 
     let am_buf_name = quote::format_ident!("{base}_am_buf");
@@ -552,16 +554,11 @@ fn create_buf_ops(
             quote! {}, //no lock since its native atomic
             quote! { #slice },
         )
-    } else if array_type == "LocalLockArray" {
+    } else if array_type == "LocalLockArray" || array_type == "GlobalLockArray" {
         (
             quote! {}, //no explicit lock since the slice handle is a lock guard
             quote! {let mut slice = self.data.write_local_data().await; }, //this is the lock
         )
-    } else if array_type == "GlobalLockArray" {
-        (
-            quote! {}, //no explicit lock since the slice handle is a lock guard
-            quote! {let mut slice = self.data.write_local_data().await;}, //this is the lock
-        )
     } else if array_type == "ReadOnlyArray" {
         (
             quote! {}, //no explicit lock since the slice handle is a lock guard
@@ -1533,10 +1530,10 @@ pub(crate) fn __generate_ops_for_type_rt(item: TokenStream) -> TokenStream {
         }
         val.value
     } else {
-        panic! ("third argument of generate_ops_for_type expects 'true' or 'false' specifying whether types implement eq");
+        panic!("third argument of generate_ops_for_type expects 'true' or 'false' specifying whether types implement eq");
     };
     for t in items[3..].iter() {
-        let the_type = syn::parse_str::<syn::Type>(&t).unwrap();
+        let the_type = syn::parse_str::<syn::Type>(t).unwrap();
         let typeident = quote::format_ident!("{:}", t.trim());
         output.extend(quote! {
             impl Dist for #typeident {}

impl/src/field_info.rs

@@ -24,7 +24,7 @@ impl FieldInfo {
                     ser.extend(self.ser_path(field, *darc_iter, false));
                 }
                 syn::Type::Tuple(ty) => {
-                    ser.extend(self.ser_tuple(field, &ty, false));
+                    ser.extend(self.ser_tuple(field, ty, false));
                 }
                 _ => {
                     abort!(
@@ -46,7 +46,7 @@ impl FieldInfo {
                     ser.extend(self.ser_path(field, *darc_iter, true));
                 }
                 syn::Type::Tuple(ty) => {
-                    ser.extend(self.ser_tuple(field, &ty, true));
+                    ser.extend(self.ser_tuple(field, ty, true));
                 }
                 _ => {
                     abort!(
@@ -131,7 +131,7 @@ impl FieldInfo {
                     des.extend(self.des_path(field, *darc_iter, false));
                 }
                 syn::Type::Tuple(ty) => {
-                    des.extend(self.des_tuple(field, &ty, false));
+                    des.extend(self.des_tuple(field, ty, false));
                 }
                 _ => {
                     abort!(
@@ -153,7 +153,7 @@ impl FieldInfo {
                     des.extend(self.des_path(field, *darc_iter, true));
                 }
                 syn::Type::Tuple(ty) => {
-                    des.extend(self.des_tuple(field, &ty, true));
+                    des.extend(self.des_tuple(field, ty, true));
                 }
                 _ => {
                     abort!(

impl/src/gen_am.rs

@@ -69,13 +69,13 @@ pub(crate) fn impl_lamellar_serde_trait(
     quote! {
         impl #impl_generics #lamellar::active_messaging::LamellarSerde for #am_name #ty_generics #where_clause {
             fn serialized_size(&self)->usize{
-                #lamellar::serialized_size(self,true)
+                #lamellar::serialized_size(self)
             }
             fn serialize_into(&self,buf: &mut [u8]){
-                #lamellar::serialize_into(buf,self,true).expect("can serialize and enough space in buf");
+                #lamellar::serialize_into(buf,self).expect("can serialize and enough space in buf");
             }
             fn serialize(&self)->Vec<u8>{
-                #lamellar::serialize(self,true).expect("can serialize")
+                #lamellar::serialize(self).expect("can serialize")
             }
         }
     }
@@ -90,13 +90,13 @@ fn impl_return_lamellar_serde_trait(
     quote! {
         impl #impl_generics #lamellar::active_messaging::LamellarSerde for #am_name #ty_generics #where_clause {
             fn serialized_size(&self)->usize{
-                #lamellar::serialized_size(&self.val,true)
+                #lamellar::serialized_size(&self.val)
             }
             fn serialize_into(&self,buf: &mut [u8]){
-                #lamellar::serialize_into(buf,&self.val,true).expect("can serialize and enough space in buf");
+                #lamellar::serialize_into(buf,&self.val).expect("can serialize and enough space in buf");
             }
             fn serialize(&self)->Vec<u8>{
-                #lamellar::serialize(self,true).expect("can serialize")
+                #lamellar::serialize(self).expect("can serialize")
             }
         }
     }
@@ -113,11 +113,11 @@ pub(crate) fn impl_lamellar_result_serde_trait(
         impl #impl_generics #lamellar::active_messaging::LamellarResultSerde for #am_name #ty_generics #where_clause {
             fn serialized_result_size(&self,result: & Box<dyn std::any::Any + Sync + Send>)->usize{
                 let result  = result.downcast_ref::<#ret_type>().expect("can downcast result box");
-                #lamellar::serialized_size(result,true)
+                #lamellar::serialized_size(result)
             }
             fn serialize_result_into(&self,buf: &mut [u8],result: & Box<dyn std::any::Any + Sync + Send>){
                 let result  = result.downcast_ref::<#ret_type>().expect("can downcast result box");
-                #lamellar::serialize_into(buf,result,true).expect("can serialize and enough size in buf");
+                #lamellar::serialize_into(buf,result).expect("can serialize and enough size in buf");
             }
         }
     }
@@ -157,7 +157,7 @@ fn impl_unpack_and_register_function(
     let am_name_unpack = quote::format_ident!("{}_unpack", am_name.clone());
     quote! {
         fn #am_name_unpack #impl_generics (bytes: &[u8], cur_pe: Result<usize,#lamellar::IdError>) -> std::sync::Arc<dyn #lamellar::active_messaging::RemoteActiveMessage + Sync + Send>  {
-            let __lamellar_data: std::sync::Arc<#am_name #ty_generics> = std::sync::Arc::new(#lamellar::deserialize(&bytes,true).expect("can deserialize into remote active message"));
+            let __lamellar_data: std::sync::Arc<#am_name #ty_generics> = std::sync::Arc::new(#lamellar::deserialize(&bytes).expect("can deserialize into remote active message"));
             <#am_name #ty_generics as #lamellar::active_messaging::DarcSerde>::des(&__lamellar_data,cur_pe);
             __lamellar_data
         }
@@ -252,7 +252,7 @@ fn gen_am_body(
     let mut stmts = exec_fn.stmts;
 
     let (ret_statement, bytes_buf) = if let Some(stmt) = stmts.pop() {
-        gen_return_stmt(am_type, &stmt, &ret_struct_name, &lamellar, local)
+        gen_return_stmt(am_type, &stmt, ret_struct_name, lamellar, local)
     } else {
         (
             quote! {#lamellar::active_messaging::LamellarReturn::Unit},
@@ -283,7 +283,7 @@ fn gen_return_stmt(
             #lamellar::active_messaging::LamellarReturn::Unit
         },
         AmType::ReturnData(ref ret) => {
-            let last_expr = get_expr(&last_stmt)
+            let last_expr = get_expr(last_stmt)
                 .expect("failed to get exec return value (try removing the last \";\")");
             let last_expr =
                 quote_spanned! {last_stmt.span()=> let __lamellar_last_expr: #ret = #last_expr; };
@@ -318,7 +318,7 @@ fn gen_return_stmt(
             }
         }
         AmType::ReturnAm(ret, _) => {
-            let last_expr = get_expr(&last_stmt)
+            let last_expr = get_expr(last_stmt)
                 .expect("failed to get exec return value (try removing the last \";\")");
             let last_expr =
                 quote_spanned! {last_stmt.span()=> let __lamellar_last_expr: #ret = #last_expr; };
@@ -406,7 +406,7 @@ pub(crate) fn generate_am(
 
     let generics = input.generics.clone();
 
-    let (am_body, bytes_buf) = gen_am_body(&input, &am_type, &return_struct_name, &lamellar, local);
+    let (am_body, bytes_buf) = gen_am_body(input, &am_type, &return_struct_name, lamellar, local);
 
     let (return_type, return_struct) = {
         match am_type {
@@ -415,10 +415,10 @@ pub(crate) fn generate_am(
                 let return_type = quote! {#output};
                 let return_struct = impl_return_struct(
                     &generics,
-                    &am_data_header,
+                    am_data_header,
                     &return_struct_name,
                     &return_type,
-                    &lamellar,
+                    lamellar,
                     bytes_buf,
                     local,
                 );
@@ -429,10 +429,10 @@ pub(crate) fn generate_am(
     };
 
     let lamellar_active_message =
-        impl_lamellar_active_message_trait(&generics, &orig_name, &am_body, &lamellar);
-    let local_am = impl_local_am_trait(&generics, &orig_name, &return_type, &lamellar);
+        impl_lamellar_active_message_trait(&generics, &orig_name, &am_body, lamellar);
+    let local_am = impl_local_am_trait(&generics, &orig_name, &return_type, lamellar);
     let remote_trait_impls =
-        impl_remote_traits(&generics, &orig_name, &return_type, &lamellar, local);
+        impl_remote_traits(&generics, &orig_name, &return_type, lamellar, local);
 
     let expanded = quote_spanned! {am_body.span()=>
         #lamellar_active_message
@@ -467,6 +467,7 @@ pub(crate) fn generate_am(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn create_am_struct(
     generics: &syn::Generics,
     attributes: &proc_macro2::TokenStream,

impl/src/gen_am_group.rs

@@ -184,6 +184,7 @@ fn gen_am_group_return_stmt(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn impl_am_group_remote(
     generics: &syn::Generics,
     am_group_am_name: &syn::Ident,
@@ -440,7 +441,7 @@ pub(crate) fn generate_am_group(
         }
     };
 
-    let am_group_remote_body = gen_am_group_remote_body2(&orig_name, &input);
+    let am_group_remote_body = gen_am_group_remote_body2(&orig_name, input);
 
     let (ret_contatiner, ret_push, ret_stmt) =
         gen_am_group_return_stmt(&am_type, &am_group_return_name, lamellar, false);
@@ -453,15 +454,15 @@ pub(crate) fn generate_am_group(
         &ret_contatiner,
         &ret_push,
         &ret_stmt,
-        &lamellar,
+        lamellar,
     );
 
     let am_group_return = impl_return_struct(
         &generics,
-        &am_data_header,
+        am_data_header,
         &am_group_return_name,
         &ret_type,
-        &lamellar,
+        lamellar,
         false,
         local,
     );
@@ -473,7 +474,7 @@ pub(crate) fn generate_am_group(
         &am_group_am_name,
         &am_group_user_name,
         &inner_ret_type,
-        &lamellar,
+        lamellar,
     );
 
     let mut am_user_generics = generics.clone();
@@ -537,6 +538,7 @@ pub(crate) fn generate_am_group(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn create_am_group_remote(
     generics: &syn::Generics,
     attributes: &proc_macro2::TokenStream,
@@ -592,7 +594,7 @@ fn create_am_group_remote(
         }
     });
 
-    let my_len = if fields.names().len() > 0 {
+    let my_len = if !fields.names().is_empty() {
         let f = &fields.names()[0];
         quote! {
             self.#f.len()
@@ -638,6 +640,7 @@ fn create_am_group_remote(
     )
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn create_am_group_structs(
     generics: &syn::Generics,
     attributes: &proc_macro2::TokenStream,
@@ -653,7 +656,7 @@ pub(crate) fn create_am_group_structs(
     let am_group_user_struct = generate_am_group_user_struct(
         generics,
         vis,
-        &get_am_group_user_name(&name),
+        &get_am_group_user_name(name),
         &get_am_group_name(&format_ident!("{}", name)),
     );