fix CI formatter check

Author: matteius

crates/diff-engine/src/changes.rs

@@ -882,7 +882,7 @@ impl ChangeClassifier {
         1 + ast
             .children
             .iter()
-            .map(|child| Self::count_ast_nodes(child))
+            .map(Self::count_ast_nodes)
             .sum::<usize>()
     }
 
@@ -894,7 +894,7 @@ impl ChangeClassifier {
             1 + ast
                 .children
                 .iter()
-                .map(|child| Self::calculate_ast_depth(child))
+                .map(Self::calculate_ast_depth)
                 .max()
                 .unwrap_or(0)
         }
@@ -1240,33 +1240,42 @@ impl ChangeClassifier {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use smart_diff_parser::NodeMetadata;
+    use smart_diff_parser::{ElementType, NodeMetadata};
     use smart_diff_semantic::{
-        ComplexityMetrics, EnhancedFunctionSignature, FunctionType, ParameterInfo, TypeSignature,
+        EnhancedFunctionSignature, FunctionComplexityMetrics, FunctionType, TypeSignature,
         Visibility,
     };
     use std::collections::HashMap;
 
     fn create_test_code_element(name: &str, file_path: &str, start_line: usize) -> CodeElement {
         CodeElement {
+            id: format!("test_{}", name),
             name: name.to_string(),
             file_path: file_path.to_string(),
             start_line,
             end_line: start_line + 10,
-            element_type: "function".to_string(),
+            element_type: ElementType::Function,
+            signature: Some(format!("fn {}()", name)),
+            hash: format!("hash_{}", name),
         }
     }
 
     fn create_test_ast_node(
         node_type: smart_diff_parser::NodeType,
         children: Vec<ASTNode>,
     ) -> ASTNode {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        static COUNTER: AtomicUsize = AtomicUsize::new(0);
+        let id = COUNTER.fetch_add(1, Ordering::SeqCst);
+
         ASTNode {
+            id: format!("test_node_{}", id),
             node_type,
             children,
             metadata: NodeMetadata {
                 line: 1,
                 column: 1,
+                original_text: String::new(),
                 attributes: HashMap::new(),
             },
         }
@@ -1275,25 +1284,31 @@ mod tests {
     fn create_test_signature(name: &str, complexity: u32) -> EnhancedFunctionSignature {
         EnhancedFunctionSignature {
             name: name.to_string(),
+            qualified_name: name.to_string(),
             parameters: Vec::new(),
-            return_type: TypeSignature::Simple("void".to_string()),
+            return_type: TypeSignature::new("void".to_string()),
             visibility: Visibility::Public,
-            function_type: FunctionType::Regular,
-            is_async: false,
-            is_static: false,
-            is_abstract: false,
+            function_type: FunctionType::Function,
+            modifiers: Vec::new(),
             generic_parameters: Vec::new(),
-            throws: Vec::new(),
             annotations: Vec::new(),
-            complexity_metrics: ComplexityMetrics {
-                cyclomatic_complexity: complexity,
-                cognitive_complexity: complexity,
+            file_path: String::new(),
+            line: 0,
+            column: 0,
+            end_line: 0,
+            complexity_metrics: Some(FunctionComplexityMetrics {
+                cyclomatic_complexity: complexity as usize,
+                cognitive_complexity: complexity as usize,
                 nesting_depth: 2,
                 parameter_count: 0,
-                return_points: 1,
                 lines_of_code: 10,
-            },
+                branch_count: 1,
+                loop_count: 0,
+                call_count: 0,
+            }),
             dependencies: Vec::new(),
+            signature_hash: String::new(),
+            normalized_hash: String::new(),
         }
     }
 
@@ -1485,7 +1500,7 @@ mod tests {
                 smart_diff_parser::NodeType::Block,
                 vec![
                     create_test_ast_node(smart_diff_parser::NodeType::IfStatement, Vec::new()),
-                    create_test_ast_node(smart_diff_parser::NodeType::WhileStatement, Vec::new()),
+                    create_test_ast_node(smart_diff_parser::NodeType::WhileLoop, Vec::new()),
                 ],
             )],
         );

crates/diff-engine/src/cross_file_tracker.rs

@@ -282,7 +282,6 @@ impl CrossFileTracker {
         Ok(result)
     }
     #[allow(clippy::type_complexity)]
-
     /// Identify functions that are unmatched within their original files
     fn identify_unmatched_functions(
         &mut self,
@@ -1025,6 +1024,7 @@ mod tests {
     use smart_diff_semantic::{FunctionType, TypeSignature, Visibility};
     use std::collections::HashMap;
 
+    #[allow(dead_code)]
     fn create_test_function_signature(name: &str, file_path: &str) -> EnhancedFunctionSignature {
         EnhancedFunctionSignature {
             name: name.to_string(),
@@ -1047,13 +1047,20 @@ mod tests {
         }
     }
 
+    #[allow(dead_code)]
     fn create_test_ast_node() -> ASTNode {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        static COUNTER: AtomicUsize = AtomicUsize::new(0);
+        let id = COUNTER.fetch_add(1, Ordering::SeqCst);
+
         ASTNode {
+            id: format!("test_node_{}", id),
             node_type: smart_diff_parser::NodeType::Function,
             children: Vec::new(),
             metadata: NodeMetadata {
                 line: 1,
                 column: 1,
+                original_text: String::new(),
                 attributes: HashMap::new(),
             },
         }

crates/diff-engine/src/refactoring.rs

@@ -575,8 +575,8 @@ impl RefactoringDetector {
 
         let mut matrix = vec![vec![0; len2 + 1]; len1 + 1];
 
-        for i in 0..=len1 {
-            matrix[i][0] = i;
+        for (i, row) in matrix.iter_mut().enumerate().take(len1 + 1) {
+            row[0] = i;
         }
         for j in 0..=len2 {
             matrix[0][j] = j;
@@ -994,7 +994,7 @@ impl RefactoringDetector {
                 .filter(|c| c.change_type == ChangeType::Modify)
                 .collect();
 
-            if additions.len() >= 2 && modifications.len() >= 1 {
+            if additions.len() >= 2 && !modifications.is_empty() {
                 // Check if additions are in the same new file
                 if let Some(first_addition) = additions.first() {
                     if let Some(target) = &first_addition.target {
@@ -1052,7 +1052,7 @@ impl RefactoringDetector {
                 .filter(|c| c.change_type == ChangeType::Modify)
                 .collect();
 
-            if deletions.len() >= 2 && modifications.len() >= 1 {
+            if deletions.len() >= 2 && !modifications.is_empty() {
                 // Check if deletions are from the same file
                 if let Some(first_deletion) = deletions.first() {
                     if let Some(source) = &first_deletion.source {
@@ -1764,13 +1764,11 @@ impl RefactoringDetector {
         deleted: &Change,
         modified: &Change,
     ) -> RefactoringAnalysis {
-        let mut characteristics = Vec::new();
-
-        characteristics.push(RefactoringCharacteristic {
+        let characteristics = vec![RefactoringCharacteristic {
             characteristic_type: RefactoringCharacteristicType::CodeInlining,
             value: "Method inlined into calling function".to_string(),
             confidence: 0.8,
-        });
+        }];
 
         RefactoringAnalysis {
             characteristics,
@@ -2445,16 +2443,19 @@ impl RefactoringDetector {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use smart_diff_parser::{ChangeDetail, CodeElement};
+    use smart_diff_parser::{ChangeDetail, CodeElement, ElementType};
     use std::collections::HashMap;
 
     fn create_test_code_element(name: &str, file_path: &str, start_line: usize) -> CodeElement {
         CodeElement {
+            id: format!("test_{}", name),
             name: name.to_string(),
             file_path: file_path.to_string(),
             start_line,
             end_line: start_line + 10,
-            element_type: "function".to_string(),
+            element_type: ElementType::Function,
+            signature: Some(format!("fn {}()", name)),
+            hash: format!("hash_{}", name),
         }
     }
 
@@ -2785,8 +2786,10 @@ mod tests {
 
     #[test]
     fn test_confidence_threshold_filtering() {
-        let mut config = RefactoringDetectionConfig::default();
-        config.min_confidence_threshold = 0.8;
+        let config = RefactoringDetectionConfig {
+            min_confidence_threshold: 0.8,
+            ..Default::default()
+        };
 
         let detector = RefactoringDetector::with_config(Language::Java, config);
 

crates/diff-engine/src/smart_matcher.rs

@@ -260,7 +260,7 @@ impl SmartMatcher {
         1 + node
             .children
             .iter()
-            .map(|child| Self::count_ast_nodes(child))
+            .map(Self::count_ast_nodes)
             .sum::<usize>()
     }
 
@@ -308,7 +308,7 @@ impl SmartMatcher {
             1 + node
                 .children
                 .iter()
-                .map(|child| Self::calculate_ast_depth(child))
+                .map(Self::calculate_ast_depth)
                 .max()
                 .unwrap_or(0)
         }

crates/diff-engine/src/tree_edit.rs

@@ -320,6 +320,7 @@ impl TreeEditDistance {
     }
 
     /// Perform postorder traversal and calculate leftmost leaves
+    #[allow(clippy::only_used_in_recursion)]
     fn postorder_traversal(
         &self,
         tree: &ASTNode,
@@ -415,6 +416,7 @@ impl TreeEditDistance {
     }
 
     /// Compute forest distance for Zhang-Shasha algorithm
+    #[allow(clippy::too_many_arguments)]
     fn compute_forest_distance(
         &self,
         i: usize,
@@ -541,17 +543,17 @@ impl TreeEditDistance {
 
         if n > m {
             // More deletions
-            for i in m..n {
+            for (i, node) in postorder1.iter().enumerate().take(n).skip(m) {
                 operations.push(EditOperation::Delete {
-                    node: format!("{:?}", postorder1[i]),
+                    node: format!("{:?}", node),
                     position: i,
                 });
             }
         } else if m > n {
             // More insertions
-            for i in n..m {
+            for (i, node) in postorder2.iter().enumerate().take(m).skip(n) {
                 operations.push(EditOperation::Insert {
-                    node: format!("{:?}", postorder2[i]),
+                    node: format!("{:?}", node),
                     position: i,
                 });
             }
@@ -652,12 +654,18 @@ mod tests {
     use std::collections::HashMap;
 
     fn create_test_node(node_type: NodeType, children: Vec<ASTNode>) -> ASTNode {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        static COUNTER: AtomicUsize = AtomicUsize::new(0);
+        let id = COUNTER.fetch_add(1, Ordering::SeqCst);
+
         ASTNode {
+            id: format!("test_node_{}", id),
             node_type,
             children,
             metadata: NodeMetadata {
                 line: 1,
                 column: 1,
+                original_text: String::new(),
                 attributes: HashMap::new(),
             },
         }
@@ -799,7 +807,7 @@ mod tests {
         let ted = TreeEditDistance::with_defaults();
 
         let tree1 = create_leaf_node(NodeType::IfStatement);
-        let tree2 = create_leaf_node(NodeType::WhileStatement);
+        let tree2 = create_leaf_node(NodeType::WhileLoop);
 
         let distance = ted.calculate_distance(&tree1, &tree2);
         assert_eq!(distance, 0.5); // Reduced cost for similar statement types
@@ -844,7 +852,7 @@ mod tests {
                 create_test_node(
                     NodeType::Block,
                     vec![create_test_node(
-                        NodeType::WhileStatement,
+                        NodeType::WhileLoop,
                         vec![
                             create_leaf_node(NodeType::BinaryExpression),
                             create_leaf_node(NodeType::Block),
@@ -885,9 +893,11 @@ mod tests {
 
     #[test]
     fn test_pruning_heuristics() {
-        let mut config = ZhangShashaConfig::default();
-        config.max_nodes = 2; // Very small limit to trigger pruning
-        config.enable_pruning = true;
+        let config = ZhangShashaConfig {
+            max_nodes: 2, // Very small limit to trigger pruning
+            enable_pruning: true,
+            ..Default::default()
+        };
 
         let ted = TreeEditDistance::new(config);
 
@@ -897,7 +907,7 @@ mod tests {
             vec![
                 create_leaf_node(NodeType::Identifier),
                 create_leaf_node(NodeType::Block),
-                create_leaf_node(NodeType::Statement),
+                create_leaf_node(NodeType::ReturnStatement),
             ],
         );
 
@@ -925,8 +935,8 @@ mod tests {
                 create_test_node(
                     NodeType::Block,
                     vec![
-                        create_leaf_node(NodeType::Statement),
-                        create_leaf_node(NodeType::Statement),
+                        create_leaf_node(NodeType::ReturnStatement),
+                        create_leaf_node(NodeType::ExpressionStatement),
                     ],
                 ),
             ],
@@ -946,13 +956,13 @@ mod tests {
                 NodeType::Block,
                 vec![create_test_node(
                     NodeType::IfStatement,
-                    vec![create_leaf_node(NodeType::Expression)],
+                    vec![create_leaf_node(NodeType::BinaryExpression)],
                 )],
             )],
         );
 
         let depth = ted.calculate_depth(&tree);
-        assert_eq!(depth, 4); // Function -> Block -> IfStatement -> Expression
+        assert_eq!(depth, 4); // Function -> Block -> IfStatement -> BinaryExpression
     }
 
     #[test]