Fix Clippy warnings (#47)

Handy-caT · the2pizza · web-flow · commit 385957480d26 · 2025-02-13T21:55:33.000+03:00
Co-authored-by: Kira Sotnikov &lt;s8tn1kv@gmail.com&gt;
diff --git a/codegen/src/persist_index/generator.rs b/codegen/src/persist_index/generator.rs
@@ -185,7 +185,7 @@ impl Generator {
             .collect::<Vec<_>>();
 
         quote! {
-            pub fn persist<T>(&mut self, path: &String, info: &mut GeneralPage<SpaceInfoData<T>>) -> eyre::Result<()>
+            pub fn persist<T>(&mut self, path: &str, info: &mut GeneralPage<SpaceInfoData<T>>) -> eyre::Result<()>
             where T: rkyv::Archive
                 + for<'a> rkyv::Serialize<
                             rkyv::rancor::Strategy<
@@ -306,7 +306,7 @@ impl Generator {
             .collect::<Vec<_>>();
 
         quote! {
-            pub fn parse_from_file(path: &String, map: &std::collections::HashMap<String, Vec<Interval>>) -> eyre::Result<Self> {
+            pub fn parse_from_file(path: &str, map: &std::collections::HashMap<String, Vec<Interval>>) -> eyre::Result<Self> {
                 #(#field_names_literals)*
 
                 Ok(Self {
diff --git a/codegen/src/persist_table/generator/mod.rs b/codegen/src/persist_table/generator/mod.rs
@@ -22,9 +22,9 @@ impl WorktableNameGenerator {
         )
     }
 
-    pub fn get_space_ident(&self) -> Ident {
-        Ident::new(format!("{}Space", self.name).as_str(), Span::mixed_site())
-    }
+    //pub fn get_space_ident(&self) -> Ident {
+    //    Ident::new(format!("{}Space", self.name).as_str(), Span::mixed_site())
+    //}
 
     pub fn get_dir_name(&self) -> String {
         self.name.from_case(Case::Pascal).to_case(Case::Snake)
diff --git a/codegen/src/worktable/generator/index.rs b/codegen/src/worktable/generator/index.rs
@@ -27,7 +27,7 @@ impl Generator {
             .indexes
             .iter()
             .map(|(i, idx)| {
-                let t = self.columns.columns_map.get(&i);
+                let t = self.columns.columns_map.get(i);
                 let i = &idx.name;
 
                 if idx.is_unique {
diff --git a/codegen/src/worktable/generator/queries/delete.rs b/codegen/src/worktable/generator/queries/delete.rs
@@ -72,22 +72,18 @@ impl Generator {
                     format!("delete_{snake_case_name}").as_str(),
                     Span::mixed_site(),
                 );
-                let index = self
-                    .columns
-                    .indexes
-                    .values()
-                    .find(|idx| idx.field.to_string() == op.by.to_string());
+                let index = self.columns.indexes.values().find(|idx| idx.field == op.by);
                 let type_ = self.columns.columns_map.get(&op.by).unwrap();
                 if let Some(index) = index {
                     let index_name = &index.name;
 
                     if index.is_unique {
-                        Self::gen_unique_delete(&type_, &method_ident, index_name)
+                        Self::gen_unique_delete(type_, &method_ident, index_name)
                     } else {
-                        Self::gen_non_unique_delete(&type_, &method_ident, index_name)
+                        Self::gen_non_unique_delete(type_, &method_ident, index_name)
                     }
                 } else {
-                    Self::gen_brute_force_delete_field(&op.by, &type_, &method_ident)
+                    Self::gen_brute_force_delete_field(&op.by, type_, &method_ident)
                 }
             })
             .collect::<Vec<_>>();
diff --git a/codegen/src/worktable/generator/queries/type.rs b/codegen/src/worktable/generator/queries/type.rs
@@ -17,7 +17,7 @@ impl Generator {
             .map(|s| {
                 let type_ident = Ident::new(s.to_string().as_str(), Span::mixed_site());
                 let type_upper =
-                    Ident::new(&s.to_string().to_uppercase().as_str(), Span::mixed_site());
+                    Ident::new(s.to_string().to_uppercase().as_str(), Span::mixed_site());
                 Some(quote! {
                     #[from]
                     #type_upper(#type_ident),
diff --git a/codegen/src/worktable/generator/queries/update.rs b/codegen/src/worktable/generator/queries/update.rs
@@ -95,11 +95,7 @@ impl Generator {
                     .to_string()
                     .from_case(Case::Pascal)
                     .to_case(Case::Snake);
-                let index = self
-                    .columns
-                    .indexes
-                    .values()
-                    .find(|idx| idx.field.to_string() == op.by.to_string());
+                let index = self.columns.indexes.values().find(|idx| idx.field == op.by);
 
                 let indexes_columns: Option<Vec<_>> = {
                     let columns: Vec<_> = self
@@ -126,23 +122,14 @@ impl Generator {
                     } else {
                         self.gen_non_unique_update(snake_case_name, name, index_name, idents)
                     }
-                } else {
-                    if self.columns.primary_keys.len() == 1 {
-                        if self.columns.primary_keys.first().unwrap().to_string()
-                            == op.by.to_string()
-                        {
-                            self.gen_pk_update(
-                                snake_case_name,
-                                name,
-                                idents,
-                                indexes_columns.as_ref(),
-                            )
-                        } else {
-                            todo!()
-                        }
+                } else if self.columns.primary_keys.len() == 1 {
+                    if *self.columns.primary_keys.first().unwrap() == op.by {
+                        self.gen_pk_update(snake_case_name, name, idents, indexes_columns.as_ref())
                     } else {
                         todo!()
                     }
+                } else {
+                    todo!()
                 }
             })
             .collect::<Vec<_>>();
@@ -156,7 +143,7 @@ impl Generator {
         &self,
         snake_case_name: String,
         name: &Ident,
-        idents: &Vec<Ident>,
+        idents: &[Ident],
         idx_idents: Option<&Vec<Ident>>,
     ) -> TokenStream {
         let pk_ident = &self.pk.as_ref().unwrap().ident;
@@ -228,7 +215,7 @@ impl Generator {
             quote! {}
         };
 
-        let process_diff_ident = if let Some(_) = diff {
+        let process_diff_ident = if diff.is_some() {
             quote! {
                     self.0.indexes.process_difference(link, diffs)?;
             }
@@ -293,7 +280,7 @@ impl Generator {
         snake_case_name: String,
         name: &Ident,
         index: &Ident,
-        idents: &Vec<Ident>,
+        idents: &[Ident],
     ) -> TokenStream {
         let method_ident = Ident::new(
             format!("update_{snake_case_name}").as_str(),
@@ -381,7 +368,7 @@ impl Generator {
         snake_case_name: String,
         name: &Ident,
         index: &Ident,
-        idents: &Vec<Ident>,
+        idents: &[Ident],
     ) -> TokenStream {
         let method_ident = Ident::new(
             format!("update_{snake_case_name}").as_str(),
diff --git a/codegen/src/worktable/generator/table/index_fns.rs b/codegen/src/worktable/generator/table/index_fns.rs
@@ -45,7 +45,7 @@ impl Generator {
         row_ident: Ident,
     ) -> syn::Result<TokenStream> {
         let type_ = columns_map
-            .get(&i)
+            .get(i)
             .ok_or(syn::Error::new(i.span(), "Row not found"))?;
         let fn_name = Ident::new(format!("select_by_{i}").as_str(), Span::mixed_site());
         let field_ident = &idx.name;
@@ -65,7 +65,7 @@ impl Generator {
         row_ident: Ident,
     ) -> syn::Result<TokenStream> {
         let type_ = columns_map
-            .get(&i)
+            .get(i)
             .ok_or(syn::Error::new(i.span(), "Row not found"))?;
         let fn_name = Ident::new(format!("select_by_{i}").as_str(), Span::mixed_site());
         let field_ident = &idx.name;
diff --git a/codegen/src/worktable/generator/table/mod.rs b/codegen/src/worktable/generator/table/mod.rs
@@ -75,7 +75,7 @@ impl Generator {
             quote! {}
         };
 
-        if let Some(_) = &self.config.as_ref().map(|c| c.page_size).flatten() {
+        if self.config.as_ref().and_then(|c| c.page_size).is_some() {
             quote! {
                 #derive
                 pub struct #ident(
@@ -111,7 +111,7 @@ impl Generator {
         let page_const_name = name_generator.get_page_size_const_ident();
         let inner_const_name = name_generator.get_page_inner_size_const_ident();
 
-        if let Some(page_size) = &self.config.as_ref().map(|c| c.page_size).flatten() {
+        if let Some(page_size) = &self.config.as_ref().and_then(|c| c.page_size) {
             let page_size = Literal::usize_unsuffixed(*page_size as usize);
             quote! {
                 const #page_const_name: usize = #page_size;
diff --git a/codegen/src/worktable/generator/table/select_executor.rs b/codegen/src/worktable/generator/table/select_executor.rs
@@ -10,9 +10,9 @@ impl Generator {
         let ident = name_generator.get_work_table_ident();
         let row_type = name_generator.get_row_type_ident();
 
-        let columns = self.columns.columns_map.iter().map(|(name, _)| {
+        let columns = self.columns.columns_map.keys().map(|name| {
             let lit = Literal::string(name.to_string().as_str());
-            if let Some(index) = self.columns.indexes.get(&name) {
+            if let Some(index) = self.columns.indexes.get(name) {
                 let idx_name = &index.name;
                 quote! {
                         #lit => {
@@ -81,6 +81,7 @@ impl Generator {
                             #(#columns)*
                             _ => unreachable!()
                         };
+                        #[allow(unreachable_code)]
                         core::result::Result::Ok(SelectResult::<_, Self>::new(rows).with_params(q.params).execute())
                     }
                 }
@@ -96,8 +97,8 @@ impl Generator {
         let columns = self
             .columns
             .columns_map
-            .iter()
-            .map(|(name, _)| {
+            .keys()
+            .map(|name| {
                 let lit = Literal::string(name.to_string().as_str());
                 quote! {
                     #lit => {
diff --git a/codegen/src/worktable/generator/wrapper.rs b/codegen/src/worktable/generator/wrapper.rs
@@ -26,8 +26,8 @@ impl Generator {
         let row_locks = self
             .columns
             .columns_map
-            .iter()
-            .map(|(i, _)| {
+            .keys()
+            .map(|i| {
                 let name = Ident::new(format!("{i}_lock").as_str(), Span::mixed_site());
                 quote! {
                     #name: u16,
@@ -54,8 +54,8 @@ impl Generator {
         let row_defaults = self
             .columns
             .columns_map
-            .iter()
-            .map(|(i, _)| {
+            .keys()
+            .map(|i| {
                 let name = Ident::new(format!("{i}_lock").as_str(), Span::mixed_site());
                 quote! {
                     #name: Default::default(),
@@ -91,8 +91,8 @@ impl Generator {
         let checks = self
             .columns
             .columns_map
-            .iter()
-            .map(|(i, _)| {
+            .keys()
+            .map(|i| {
                 let name = Ident::new(format!("{i}_lock").as_str(), Span::mixed_site());
                 quote! {
                     if self.#name != 0 {
diff --git a/codegen/src/worktable/mod.rs b/codegen/src/worktable/mod.rs
@@ -59,7 +59,7 @@ pub fn expand(input: TokenStream) -> syn::Result<TokenStream> {
     let update_impls = generator.gen_query_update_impl()?;
     let delete_impls = generator.gen_query_delete_impl()?;
 
-    Ok(TokenStream::from(quote! {
+    Ok(quote! {
         #pk_def
         #row_def
         #query_available_def
@@ -71,7 +71,7 @@ pub fn expand(input: TokenStream) -> syn::Result<TokenStream> {
         #select_impls
         #update_impls
         #delete_impls
-    }))
+    })
 }
 
 #[cfg(test)]
diff --git a/codegen/src/worktable/parser/punct.rs b/codegen/src/worktable/parser/punct.rs
@@ -30,7 +30,7 @@ impl Parser {
         let iter = &mut self.input_iter;
 
         if let Some(colon) = iter.peek() {
-            if let Ok(_) = comma(colon) {
+            if comma(colon).is_ok() {
                 iter.next();
             }
         }
diff --git a/codegen/src/worktable/parser/queries/operation.rs b/codegen/src/worktable/parser/queries/operation.rs
@@ -10,7 +10,7 @@ impl Parser {
         let mut ops = HashMap::new();
         while self.has_next() {
             let row = self.parse_operation()?;
-            if ops.get(&row.name).is_some() {
+            if ops.contains_key(&row.name) {
                 return Err(syn::Error::new(row.name.span(), "Non-unique query name"));
             }
             ops.insert(row.name.clone(), row);
diff --git a/performance_measurement/codegen/src/performance_measurement.rs b/performance_measurement/codegen/src/performance_measurement.rs
@@ -21,12 +21,12 @@ pub fn expand(attr: TokenStream, item: TokenStream) -> syn::Result<TokenStream>
     let fn_sig = &input_fn.sig;
     let fn_vis = &input_fn.vis;
 
-    let mut attr = parse_attr(attr)?;
+    let attr = parse_attr(attr)?;
 
     let mut test_sig = input_fn.sig.clone();
     test_sig.ident = Ident::new(format!("__{}", test_sig.ident).as_str(), item.span());
 
-    let fn_name = Literal::string(format!("{}::{}", attr.name, fn_name.to_string()).as_str());
+    let fn_name = Literal::string(format!("{}::{}", attr.name, fn_name).as_str());
 
     Ok(quote! {
         #fn_vis #fn_sig {
@@ -52,7 +52,7 @@ pub fn parse_name(iter: &mut token_stream::IntoIter, attr: &TokenStream) -> syn:
         .next()
         .ok_or(syn::Error::new(attr.span(), "Expected `prefix_name` field"))?;
     if let TokenTree::Ident(field) = name_field {
-        if field.to_string() != "prefix_name".to_string() {
+        if field != *"prefix_name" {
             return Err(syn::Error::new(attr.span(), "Expected `prefix_name` field"));
         };
     } else {
@@ -63,7 +63,7 @@ pub fn parse_name(iter: &mut token_stream::IntoIter, attr: &TokenStream) -> syn:
         .next()
         .ok_or(syn::Error::new(attr.span(), "Expected `=`"))?;
     if let TokenTree::Punct(eq) = eq {
-        if eq.to_string() != "=".to_string() {
+        if eq.to_string() != *"=" {
             return Err(syn::Error::new(attr.span(), "Expected `=`"));
         };
     } else {
diff --git a/src/in_memory/data.rs b/src/in_memory/data.rs
@@ -150,6 +150,10 @@ impl<Row, const DATA_LENGTH: usize> Data<Row, DATA_LENGTH> {
         Ok(link)
     }
 
+    /// # Safety
+    /// This function is `unsafe` because it returns a mutable reference to an archived row.
+    /// The caller must ensure that there are no other references to the same data
+    /// while this function is being used, as it could lead to undefined behavior.
     pub unsafe fn get_mut_row_ref(
         &self,
         link: Link,
@@ -181,26 +185,26 @@ impl<Row, const DATA_LENGTH: usize> Data<Row, DATA_LENGTH> {
 
         let inner_data = unsafe { &*self.inner_data.get() };
         let bytes = &inner_data[link.offset as usize..(link.offset + link.length) as usize];
-        Ok(unsafe { rkyv::access_unchecked::<<Row as Archive>::Archived>(&bytes[..]) })
+        Ok(unsafe { rkyv::access_unchecked::<<Row as Archive>::Archived>(bytes) })
     }
 
-    #[cfg_attr(
-        feature = "perf_measurements",
-        performance_measurement(prefix_name = "DataRow")
-    )]
+    //#[cfg_attr(
+    //    feature = "perf_measurements",
+    //    performance_measurement(prefix_name = "DataRow")
+    //)]
     pub fn get_row(&self, link: Link) -> Result<Row, ExecutionError>
     where
         Row: Archive,
         <Row as Archive>::Archived: Deserialize<Row, HighDeserializer<rkyv::rancor::Error>>,
     {
         let row = self.get_row_ref(link)?;
-        return Ok(rkyv::deserialize::<_, rkyv::rancor::Error>(row)
-            .map_err(|_| ExecutionError::DeserializeError)?);
+        rkyv::deserialize::<_, rkyv::rancor::Error>(row)
+            .map_err(|_| ExecutionError::DeserializeError)
     }
 
     pub fn get_bytes(&self) -> [u8; DATA_LENGTH] {
         let data = unsafe { &*self.inner_data.get() };
-        data.0.clone()
+        data.0
     }
 }
 
@@ -422,7 +426,7 @@ mod tests {
 
         let links = other_links
             .into_iter()
-            .chain(links.into_iter())
+            .chain(links)
             .map(|v| v.unwrap())
             .collect::<Vec<_>>();
 
diff --git a/src/in_memory/pages.rs b/src/in_memory/pages.rs
diff --git a/src/lock/mod.rs b/src/lock/mod.rs
diff --git a/src/lock/set.rs b/src/lock/set.rs
diff --git a/src/primary_key.rs b/src/primary_key.rs
diff --git a/tests/persistence/mod.rs b/tests/persistence/mod.rs
diff --git a/tests/worktable/base.rs b/tests/worktable/base.rs
diff --git a/tests/worktable/index.rs b/tests/worktable/index.rs

Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,9 @@ impl WorktableNameGenerator {`
`22`	`22`	`)`
`23`	`23`	`}`
`24`	`24`
`25`		`- pub fn get_space_ident(&self) -> Ident {`
`26`		`- Ident::new(format!("{}Space", self.name).as_str(), Span::mixed_site())`
`27`		`- }`
	`25`	`+ //pub fn get_space_ident(&self) -> Ident {`
	`26`	`+ // Ident::new(format!("{}Space", self.name).as_str(), Span::mixed_site())`
	`27`	`+ //}`
`28`	`28`
`29`	`29`	`pub fn get_dir_name(&self) -> String {`
`30`	`30`	`self.name.from_case(Case::Pascal).to_case(Case::Snake)`