clippy fixes

Author: Handy-caT

codegen/src/worktable/parser/punct.rs

@@ -29,10 +29,10 @@ impl Parser {
     pub fn try_parse_comma(&mut self) -> syn::Result<()> {
         let iter = &mut self.input_iter;
 
-        if let Some(colon) = iter.peek() {
-            if comma(colon).is_ok() {
-                iter.next();
-            }
+        if let Some(colon) = iter.peek()
+            && comma(colon).is_ok()
+        {
+            iter.next();
         }
 
         Ok(())

src/in_memory/data.rs

@@ -165,7 +165,7 @@ impl<Row, const DATA_LENGTH: usize> Data<Row, DATA_LENGTH> {
     pub unsafe fn get_mut_row_ref(
         &self,
         link: Link,
-    ) -> Result<Seal<<Row as Archive>::Archived>, ExecutionError>
+    ) -> Result<Seal<'_, <Row as Archive>::Archived>, ExecutionError>
     where
         Row: Archive,
         <Row as Archive>::Archived: Portable,

src/lock/map.rs

@@ -49,12 +49,11 @@ where
         LockType: RowLock,
     {
         let mut set = self.map.write();
-        if let Some(lock) = set.get(key).cloned() {
-            if let Ok(guard) = lock.try_read() {
-                if !guard.is_locked() {
-                    set.remove(key);
-                }
-            }
+        if let Some(lock) = set.get(key).cloned()
+            && let Ok(guard) = lock.try_read()
+            && !guard.is_locked()
+        {
+            set.remove(key);
         }
     }
 

src/persistence/operation/batch.rs

@@ -246,48 +246,48 @@ where
                 .prepared_index_evs
                 .as_ref()
                 .expect("should be set before 0 iteration");
-            if let Some(id) = prepared_evs.primary_evs.first().map(|ev| ev.id()) {
-                if !id.is_next_for(last_ids.primary_id)
-                    && last_ids.primary_id != IndexChangeEventId::default()
-                {
-                    let mut possibly_valid = false;
-                    if id.inner().overflowing_sub(last_ids.primary_id.inner()).0 == 2 {
-                        // TODO: for split sometimes this happens
-                        let ev = prepared_evs.primary_evs.first().unwrap();
-                        if let ChangeEvent::SplitNode { .. } = ev {
-                            possibly_valid = true
-                        }
-                        if attempts > 8 {
-                            possibly_valid = true
-                        }
+            if let Some(id) = prepared_evs.primary_evs.first().map(|ev| ev.id())
+                && !id.is_next_for(last_ids.primary_id)
+                && last_ids.primary_id != IndexChangeEventId::default()
+            {
+                let mut possibly_valid = false;
+                if id.inner().overflowing_sub(last_ids.primary_id.inner()).0 == 2 {
+                    // TODO: for split sometimes this happens
+                    let ev = prepared_evs.primary_evs.first().unwrap();
+                    if let ChangeEvent::SplitNode { .. } = ev {
+                        possibly_valid = true
                     }
-
-                    if !possibly_valid {
-                        self.ops.extend(ops_to_remove);
-                        return Ok(None);
+                    if attempts > 8 {
+                        possibly_valid = true
                     }
                 }
+
+                if !possibly_valid {
+                    self.ops.extend(ops_to_remove);
+                    return Ok(None);
+                }
             }
             let secondary_first = prepared_evs.secondary_evs.first_evs();
             for (index, id) in secondary_first {
                 let Some(last) = last_ids.secondary_ids.get(&index) else {
                     continue;
                 };
-                if let Some(id) = id {
-                    if !id.is_next_for(*last) && *last != IndexChangeEventId::default() {
-                        let mut possibly_valid = false;
-                        if id.inner().overflowing_sub(last.inner()).0 == 2 {
-                            // TODO: for split sometimes this happens
-                            possibly_valid = prepared_evs.secondary_evs.is_first_ev_is_split(index);
-                            if attempts > 8 {
-                                possibly_valid = true
-                            }
+                if let Some(id) = id
+                    && !id.is_next_for(*last)
+                    && *last != IndexChangeEventId::default()
+                {
+                    let mut possibly_valid = false;
+                    if id.inner().overflowing_sub(last.inner()).0 == 2 {
+                        // TODO: for split sometimes this happens
+                        possibly_valid = prepared_evs.secondary_evs.is_first_ev_is_split(index);
+                        if attempts > 8 {
+                            possibly_valid = true
                         }
+                    }
 
-                        if !possibly_valid {
-                            self.ops.extend(ops_to_remove);
-                            return Ok(None);
-                        }
+                    if !possibly_valid {
+                        self.ops.extend(ops_to_remove);
+                        return Ok(None);
                     }
                 }
             }

src/persistence/task.rs

@@ -413,10 +413,10 @@ impl<PrimaryKeyGenState, PrimaryKey, SecondaryKeys, AvailableIndexes>
                 } else {
                     None
                 };
-                if let Some(op) = op {
-                    if let Err(err) = analyzer.push(op) {
-                        tracing::warn!("Error while feeding data to analyzer: {}", err);
-                    }
+                if let Some(op) = op
+                    && let Err(err) = analyzer.push(op.clone())
+                {
+                    tracing::warn!("Error while feeding data to analyzer: {}", err);
                 }
                 let ops_available_iter = engine_queue.pop_iter();
                 if let Err(err) = analyzer.extend_from_iter(ops_available_iter) {