fix clippy warnings

Author: connortsui20

optd/src/core/memo/memory.rs

@@ -1,13 +1,9 @@
-use std::collections::hash_map::Entry;
-use std::collections::{HashMap, HashSet, VecDeque};
-
-use async_recursion::async_recursion;
-
-use crate::cir::Child;
-
-use super::Memoize;
 use super::merge_repr::Representative;
 use super::*;
+use crate::core::cir::Child;
+use async_recursion::async_recursion;
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet, VecDeque};
 
 /// An in-memory implementation of the memo table.
 #[derive(Default)]
@@ -347,7 +343,7 @@ impl Memoize for MemoryMemo {
             .transform_dependency
             .get(&logical_expr_id)
             .and_then(|status_map| status_map.get(rule))
-            .map(|dep| dep.status.clone())
+            .map(|dep| dep.status)
             .unwrap_or(Status::Dirty);
         Ok(status)
     }
@@ -386,7 +382,7 @@ impl Memoize for MemoryMemo {
             .implement_dependency
             .get(&logical_expr_id)
             .and_then(|status_map| status_map.get(&(goal_id, rule.clone())))
-            .map(|dep| dep.status.clone())
+            .map(|dep| dep.status)
             .unwrap_or(Status::Dirty);
         Ok(status)
     }
@@ -422,7 +418,7 @@ impl Memoize for MemoryMemo {
         let status = self
             .cost_dependency
             .get(&physical_expr_id)
-            .map(|dep| dep.status.clone())
+            .map(|dep| dep.status)
             .unwrap_or(Status::Dirty);
         Ok(status)
     }
@@ -573,14 +569,14 @@ impl Memoize for MemoryMemo {
             match child {
                 Child::Singleton(group_id) => {
                     self.group_dependent_logical_exprs
-                        .entry(group_id.clone())
+                        .entry(*group_id)
                         .or_default()
                         .insert(logical_expr_id);
                 }
                 Child::VarLength(group_ids) => {
                     for group_id in group_ids.iter() {
                         self.group_dependent_logical_exprs
-                            .entry(group_id.clone())
+                            .entry(*group_id)
                             .or_default()
                             .insert(logical_expr_id);
                     }
@@ -624,7 +620,7 @@ impl Memoize for MemoryMemo {
                 Child::Singleton(goal_member_id) => {
                     if let GoalMemberId::GoalId(goal_id) = goal_member_id {
                         self.goal_dependent_physical_exprs
-                            .entry(goal_id.clone())
+                            .entry(*goal_id)
                             .or_default()
                             .insert(physical_expr_id);
                     }
@@ -634,13 +630,13 @@ impl Memoize for MemoryMemo {
                         match goal_member_id {
                             GoalMemberId::GoalId(goal_id) => {
                                 self.goal_dependent_physical_exprs
-                                    .entry(goal_id.clone())
+                                    .entry(*goal_id)
                                     .or_default()
                                     .insert(physical_expr_id);
                             }
                             GoalMemberId::PhysicalExpressionId(child_physical_expr_id) => {
                                 self.physical_expr_dependent_physical_exprs
-                                    .entry(child_physical_expr_id.clone())
+                                    .entry(*child_physical_expr_id)
                                     .or_default()
                                     .insert(physical_expr_id);
                             }
@@ -703,17 +699,16 @@ impl MemoryMemo {
         for child in repr_logical_expr.children.iter() {
             match child {
                 Child::Singleton(group_id) => {
-                    let repr_group_id = self.find_repr_group(group_id.clone()).await?;
+                    let repr_group_id = self.find_repr_group(*group_id).await?;
                     new_children.push(Child::Singleton(repr_group_id));
                 }
                 Child::VarLength(group_ids) => {
                     let new_group_ids = group_ids
                         .iter()
                         .map(|group_id| {
-                            let group_id = group_id.clone();
                             let self_ref = &self;
                             // TODO(Sarvesh): this is a hack to get the repr group id, i'm sure there's a better way to do this.
-                            async move { self_ref.find_repr_group(group_id).await }
+                            async move { self_ref.find_repr_group(*group_id).await }
                         })
                         .collect::<Vec<_>>();
 
@@ -742,24 +737,23 @@ impl MemoryMemo {
             match child {
                 Child::Singleton(goal_member_id) => {
                     if let GoalMemberId::GoalId(goal_id) = goal_member_id {
-                        let repr_goal_id = self.find_repr_goal(goal_id.clone()).await?;
+                        let repr_goal_id = self.find_repr_goal(*goal_id).await?;
                         new_children.push(Child::Singleton(GoalMemberId::GoalId(repr_goal_id)));
                     } else {
-                        new_children.push(Child::Singleton(goal_member_id.clone()));
+                        new_children.push(Child::Singleton(*goal_member_id));
                     }
                 }
                 Child::VarLength(goal_member_ids) => {
                     let mut new_goal_member_ids = Vec::new();
                     for goal_member_id in goal_member_ids.iter() {
                         match goal_member_id {
                             GoalMemberId::GoalId(goal_id) => {
-                                let repr_goal_id = self.find_repr_goal(goal_id.clone()).await?;
+                                let repr_goal_id = self.find_repr_goal(*goal_id).await?;
                                 new_goal_member_ids.push(GoalMemberId::GoalId(repr_goal_id));
                             }
                             GoalMemberId::PhysicalExpressionId(physical_expr_id) => {
-                                let repr_physical_expr_id = self
-                                    .find_repr_physical_expr(physical_expr_id.clone())
-                                    .await?;
+                                let repr_physical_expr_id =
+                                    self.find_repr_physical_expr(*physical_expr_id).await?;
                                 new_goal_member_ids.push(GoalMemberId::PhysicalExpressionId(
                                     repr_physical_expr_id,
                                 ));
@@ -780,7 +774,7 @@ impl MemoryMemo {
         &mut self,
         physical_expr_id: PhysicalExpressionId,
     ) -> MemoizeResult<Vec<MergePhysicalExprResult>> {
-        let (physical_expr, cost) = self.physical_exprs.get(&physical_expr_id).unwrap();
+        let (physical_expr, _cost) = self.physical_exprs.get(&physical_expr_id).unwrap();
         let repr_physical_expr = self
             .create_repr_physical_expr(physical_expr.clone())
             .await?;
@@ -796,7 +790,7 @@ impl MemoryMemo {
         let mut results = Vec::new();
         results.push(MergePhysicalExprResult {
             repr_physical_expr: repr_physical_expr_id,
-            stale_physical_exprs: stale_physical_exprs,
+            stale_physical_exprs,
         });
 
         let dependent_physical_exprs = self
@@ -808,7 +802,7 @@ impl MemoryMemo {
             for dependent_physical_expr_id in dependent_physical_exprs {
                 // TODO(Sarvesh): handle async recursion
                 let merge_physical_expr_result = self
-                    .merge_physical_exprs(dependent_physical_expr_id.clone())
+                    .merge_physical_exprs(dependent_physical_expr_id)
                     .await?;
                 results.extend(merge_physical_expr_result);
             }
@@ -825,8 +819,6 @@ impl MemoryMemo {
     ) -> MemoizeResult<(MergeGoalResult, Vec<MergePhysicalExprResult>)> {
         let goal_2 = self.goals.remove(&goal_id2).unwrap();
         let goal_1 = self.goals.get(&goal_id1).unwrap();
-        let goal_1_props = &goal_1.goal.1;
-        let goal_2_props = &goal_2.goal.1;
         self.repr_goal.merge(&goal_id2, &goal_id1);
 
         let mut merged_goal_result = MergeGoalResult {
@@ -855,8 +847,8 @@ impl MemoryMemo {
             merged_goal_result.best_expr = Some(best_expr);
         }
 
-        let mut merged_goal_info_1 = MergedGoalInfo {
-            goal_id: goal_id1.clone(),
+        let merged_goal_info_1 = MergedGoalInfo {
+            goal_id: goal_id1,
             members: goal_1.members.iter().cloned().collect(),
             seen_best_expr_before_merge: {
                 if let Some(best_expr_goal1) = best_expr_goal1 {
@@ -874,8 +866,8 @@ impl MemoryMemo {
             },
         };
 
-        let mut merged_goal_info_2 = MergedGoalInfo {
-            goal_id: goal_id2.clone(),
+        let merged_goal_info_2 = MergedGoalInfo {
+            goal_id: goal_id2,
             members: goal_2.members.iter().cloned().collect(),
             seen_best_expr_before_merge: {
                 if let Some(best_expr_goal2) = best_expr_goal2 {
@@ -895,10 +887,10 @@ impl MemoryMemo {
 
         merged_goal_result
             .merged_goals
-            .insert(goal_id1.clone(), merged_goal_info_1);
+            .insert(goal_id1, merged_goal_info_1);
         merged_goal_result
             .merged_goals
-            .insert(goal_id2.clone(), merged_goal_info_2);
+            .insert(goal_id2, merged_goal_info_2);
 
         // Now, we need to update all the physical exprs that depend on goal 2 to now depend on goal 1.
         let goal_2_dependent_physical_exprs = self
@@ -966,14 +958,13 @@ impl MemoryMemo {
 
         for goal_id1 in group_1_goals.iter() {
             for goal_id2 in group_2_goals.iter() {
-                let goal_1 = self.goals.get(&goal_id1).unwrap();
-                let goal_2 = self.goals.get(&goal_id2).unwrap();
+                let goal_1 = self.goals.get(goal_id1).unwrap();
+                let goal_2 = self.goals.get(goal_id2).unwrap();
                 let goal_1_props = &goal_1.goal.1;
                 let goal_2_props = &goal_2.goal.1;
                 if goal_1_props == goal_2_props {
-                    let (merged_goal_result, merge_physical_expr_results) = self
-                        .merge_goals_helper(goal_id1.clone(), goal_id2.clone())
-                        .await?;
+                    let (merged_goal_result, merge_physical_expr_results) =
+                        self.merge_goals_helper(*goal_id1, *goal_id2).await?;
                     result.goal_merges.push(merged_goal_result);
                     result
                         .physical_expr_merges
@@ -995,7 +986,7 @@ impl MemoryMemo {
             let repr_logical_expr_id = self.get_logical_expr_id(&repr_logical_expr).await?;
             // merge the logical exprs
             self.repr_logical_expr
-                .merge(&logical_expr_id, &repr_logical_expr_id);
+                .merge(logical_expr_id, &repr_logical_expr_id);
 
             let parent_group_id = self.logical_expr_group_index.get(logical_expr_id).unwrap();
             let parent_group_state = self.groups.get_mut(parent_group_id).unwrap();
@@ -1012,7 +1003,7 @@ impl MemoryMemo {
                     // we have another merge to do
                     // do a cascading merge between repr_parent_group_id and parent_group_id
                     let merge_result = self
-                        .merge_groups_helper(repr_parent_group_id.clone(), parent_group_id.clone())
+                        .merge_groups_helper(*repr_parent_group_id, *parent_group_id)
                         .await?;
                     // merge the cascading merge result with the current result.
                     if let Some(merge_result) = merge_result {
@@ -1031,7 +1022,7 @@ impl MemoryMemo {
                     .insert(repr_logical_expr_id);
                 // we update the index
                 self.logical_expr_group_index
-                    .insert(repr_logical_expr_id, parent_group_id.clone());
+                    .insert(repr_logical_expr_id, *parent_group_id);
             }
         }
 

optd/src/core/memo/mod.rs

@@ -1,16 +1,8 @@
-#[cfg(test)]
-pub mod memory;
-mod merge_repr;
-
+use crate::core::cir::*;
 use std::collections::{HashMap, HashSet};
 
-use async_recursion::async_recursion;
-
-use crate::cir::{
-    Cost, Goal, GoalId, GoalMemberId, GroupId, ImplementationRule, LogicalExpression,
-    LogicalExpressionId, LogicalProperties, PhysicalExpression, PhysicalExpressionId,
-    TransformationRule,
-};
+mod memory;
+mod merge_repr;
 
 /// Type alias for results returned by Memoize trait methods
 pub type MemoizeResult<T> = Result<T, MemoizeError>;