fix CI formatter check

Author: matteius

crates/diff-engine/src/changes.rs

@@ -513,14 +513,13 @@ impl ChangeClassifier {
                 .collect(),
             });
 
-            if name_similarity > self.config.rename_threshold {
-                if primary_type != ChangeType::Rename {
-                    alternatives.push(AlternativeClassification {
-                        change_type: ChangeType::Rename,
-                        confidence: name_similarity,
-                        reason: "High name similarity suggests rename".to_string(),
-                    });
-                }
+            if name_similarity > self.config.rename_threshold && primary_type != ChangeType::Rename
+            {
+                alternatives.push(AlternativeClassification {
+                    change_type: ChangeType::Rename,
+                    confidence: name_similarity,
+                    reason: "High name similarity suggests rename".to_string(),
+                });
             }
         }
 
@@ -770,11 +769,11 @@ impl ChangeClassifier {
         let mut matrix = vec![vec![0; len2 + 1]; len1 + 1];
 
         // Initialize first row and column
-        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;
+        for (j, cell) in matrix[0].iter_mut().enumerate().take(len2 + 1) {
+            *cell = j;
         }
 
         let s1_chars: Vec<char> = s1.chars().collect();
@@ -871,31 +870,31 @@ impl ChangeClassifier {
 
     /// Calculate AST complexity
     fn calculate_ast_complexity(&self, ast: &ASTNode) -> f64 {
-        let node_count = self.count_ast_nodes(ast) as f64;
-        let depth = self.calculate_ast_depth(ast) as f64;
+        let node_count = Self::count_ast_nodes(ast) as f64;
+        let depth = Self::calculate_ast_depth(ast) as f64;
 
         // Simple complexity metric based on size and depth
         (node_count * 0.7) + (depth * 0.3)
     }
 
     /// Count nodes in AST
-    fn count_ast_nodes(&self, ast: &ASTNode) -> usize {
+    fn count_ast_nodes(ast: &ASTNode) -> usize {
         1 + ast
             .children
             .iter()
-            .map(|child| self.count_ast_nodes(child))
+            .map(|child| Self::count_ast_nodes(child))
             .sum::<usize>()
     }
 
     /// Calculate AST depth
-    fn calculate_ast_depth(&self, ast: &ASTNode) -> usize {
+    fn calculate_ast_depth(ast: &ASTNode) -> usize {
         if ast.children.is_empty() {
             1
         } else {
             1 + ast
                 .children
                 .iter()
-                .map(|child| self.calculate_ast_depth(child))
+                .map(|child| Self::calculate_ast_depth(child))
                 .max()
                 .unwrap_or(0)
         }

crates/diff-engine/src/cross_file_tracker.rs

@@ -188,10 +188,12 @@ pub struct CrossFileTrackingStats {
 
 impl CrossFileTracker {
     pub fn new(language: Language, config: CrossFileTrackerConfig) -> Self {
-        let mut hungarian_config = HungarianMatcherConfig::default();
-        hungarian_config.enable_cross_file_matching = true;
-        hungarian_config.cross_file_penalty = config.cross_file_move_penalty;
-        hungarian_config.min_similarity_threshold = config.min_cross_file_similarity;
+        let hungarian_config = HungarianMatcherConfig {
+            enable_cross_file_matching: true,
+            cross_file_penalty: config.cross_file_move_penalty,
+            min_similarity_threshold: config.min_cross_file_similarity,
+            ..Default::default()
+        };
 
         let hungarian_matcher = HungarianMatcher::new(language, hungarian_config);
         let similarity_scorer = SimilarityScorer::with_defaults(language);
@@ -279,6 +281,7 @@ impl CrossFileTracker {
 
         Ok(result)
     }
+    #[allow(clippy::type_complexity)]
 
     /// Identify functions that are unmatched within their original files
     fn identify_unmatched_functions(

crates/diff-engine/src/graph_matcher.rs

@@ -57,6 +57,7 @@ impl Default for GraphMatcherConfig {
 pub struct GraphMatcher {
     config: GraphMatcherConfig,
     similarity_scorer: SimilarityScorer,
+    #[allow(dead_code)]
     language: Language,
 }
 

crates/diff-engine/src/smart_matcher.rs

@@ -5,7 +5,7 @@
 //! handle same-named functions, simple functions, and cross-file moves.
 
 use smart_diff_parser::{Change, ChangeType, CodeElement, Function, MatchResult};
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
 
 /// Configuration for smart matching
 #[derive(Debug, Clone)]
@@ -209,7 +209,7 @@ impl SmartMatcher {
         score += body_weight * body_sim;
         weight += body_weight;
 
-        let mut final_score = if weight > 0.0 { score / weight } else { 0.0 };
+        let final_score = if weight > 0.0 { score / weight } else { 0.0 };
 
         // Rule 3a: Stricter matching for different-named functions
         // If names are different, require high body similarity to avoid matching
@@ -227,7 +227,7 @@ impl SmartMatcher {
                 return 0.0;
             }
             // For moderately similar names (0.5-0.8), require 92% body similarity
-            if name_sim >= 0.5 && name_sim < 0.8 && body_sim < 0.92 {
+            if (0.5..0.8).contains(&name_sim) && body_sim < 0.92 {
                 return 0.0;
             }
             // For very different names (< 0.5), require 95% body similarity
@@ -249,18 +249,18 @@ impl SmartMatcher {
     /// Check if a function is "simple" (small body, likely a getter/setter/wrapper)
     fn is_simple_function(&self, func: &Function) -> bool {
         // Count non-empty nodes in the body
-        let node_count = self.count_ast_nodes(&func.body);
+        let node_count = Self::count_ast_nodes(&func.body);
         // Simple functions: single statement wrappers, getters, setters
         // Typically have 10 or fewer AST nodes
         node_count <= 10
     }
 
     /// Count AST nodes recursively
-    fn count_ast_nodes(&self, node: &smart_diff_parser::ASTNode) -> usize {
+    fn count_ast_nodes(node: &smart_diff_parser::ASTNode) -> usize {
         1 + node
             .children
             .iter()
-            .map(|child| self.count_ast_nodes(child))
+            .map(|child| Self::count_ast_nodes(child))
             .sum::<usize>()
     }
 
@@ -271,11 +271,11 @@ impl SmartMatcher {
         body2: &smart_diff_parser::ASTNode,
     ) -> f64 {
         // Simple structural similarity based on node count and depth
-        let count1 = self.count_ast_nodes(body1);
-        let count2 = self.count_ast_nodes(body2);
+        let count1 = Self::count_ast_nodes(body1);
+        let count2 = Self::count_ast_nodes(body2);
 
-        let depth1 = self.calculate_ast_depth(body1);
-        let depth2 = self.calculate_ast_depth(body2);
+        let depth1 = Self::calculate_ast_depth(body1);
+        let depth2 = Self::calculate_ast_depth(body2);
 
         // Node count similarity (60%)
         let count_sim = if count1.max(count2) == 0 {
@@ -301,14 +301,14 @@ impl SmartMatcher {
     }
 
     /// Calculate AST depth
-    fn calculate_ast_depth(&self, node: &smart_diff_parser::ASTNode) -> usize {
+    fn calculate_ast_depth(node: &smart_diff_parser::ASTNode) -> usize {
         if node.children.is_empty() {
             1
         } else {
             1 + node
                 .children
                 .iter()
-                .map(|child| self.calculate_ast_depth(child))
+                .map(|child| Self::calculate_ast_depth(child))
                 .max()
                 .unwrap_or(0)
         }

crates/diff-engine/src/tree_edit.rs

@@ -193,6 +193,7 @@ impl TreeEditDistance {
     }
 
     /// Check if two trees are structurally identical
+    #[allow(clippy::only_used_in_recursion)]
     fn are_trees_identical(&self, tree1: &ASTNode, tree2: &ASTNode) -> bool {
         if tree1.node_type != tree2.node_type {
             return false;
@@ -271,6 +272,7 @@ impl TreeEditDistance {
     }
 
     /// Recursively hash tree structure
+    #[allow(clippy::only_used_in_recursion)]
     fn hash_tree_recursive(
         &self,
         tree: &ASTNode,
@@ -569,6 +571,7 @@ impl TreeEditDistance {
     }
 
     /// Count total nodes in tree
+    #[allow(clippy::only_used_in_recursion)]
     fn count_nodes(&self, tree: &ASTNode) -> usize {
         1 + tree
             .children
@@ -578,6 +581,7 @@ impl TreeEditDistance {
     }
 
     /// Calculate tree depth
+    #[allow(clippy::only_used_in_recursion)]
     fn calculate_depth(&self, tree: &ASTNode) -> usize {
         if tree.children.is_empty() {
             1