Check in initial diff engine and semantic analysis

Author: matteius

Cargo.toml

@@ -32,7 +32,7 @@ tree-sitter-java = "0.20"
 tree-sitter-python = "0.20"
 tree-sitter-javascript = "0.20"
 tree-sitter-cpp = "0.20"
-tree-sitter-c-sharp = "0.20"
+tree-sitter-c = "0.20"
 
 # CLI dependencies
 clap = { version = "4.0", features = ["derive"] }

crates/diff-engine/src/changes.rs

@@ -0,0 +1,47 @@
+//! Change classification and analysis
+
+use smart_diff_parser::{Change, ChangeType, CodeElement};
+use serde::{Deserialize, Serialize};
+
+/// Change classifier that categorizes detected changes
+pub struct ChangeClassifier;
+
+impl ChangeClassifier {
+    /// Classify a change based on its characteristics
+    pub fn classify_change(&self, source: Option<&CodeElement>, target: Option<&CodeElement>) -> ChangeType {
+        match (source, target) {
+            (None, Some(_)) => ChangeType::Add,
+            (Some(_), None) => ChangeType::Delete,
+            (Some(src), Some(tgt)) => {
+                if src.name != tgt.name {
+                    if src.file_path != tgt.file_path {
+                        ChangeType::CrossFileMove
+                    } else {
+                        ChangeType::Rename
+                    }
+                } else if src.file_path != tgt.file_path {
+                    ChangeType::CrossFileMove
+                } else if src.start_line != tgt.start_line {
+                    ChangeType::Move
+                } else {
+                    ChangeType::Modify
+                }
+            }
+            (None, None) => ChangeType::Modify, // Shouldn't happen
+        }
+    }
+    
+    /// Detect if a change represents a function split
+    pub fn detect_split(&self, source: &CodeElement, targets: &[CodeElement]) -> bool {
+        targets.len() > 1 && targets.iter().all(|t| {
+            t.name.contains(&source.name) || source.name.contains(&t.name)
+        })
+    }
+    
+    /// Detect if changes represent a function merge
+    pub fn detect_merge(&self, sources: &[CodeElement], target: &CodeElement) -> bool {
+        sources.len() > 1 && sources.iter().all(|s| {
+            s.name.contains(&target.name) || target.name.contains(&s.name)
+        })
+    }
+}

crates/diff-engine/src/engine.rs

@@ -0,0 +1,103 @@
+//! Main diff engine
+
+use crate::matching::FunctionMatcher;
+use crate::tree_edit::{TreeEditDistance, EditCost};
+use crate::changes::ChangeClassifier;
+use crate::refactoring::RefactoringDetector;
+use smart_diff_parser::{Function, MatchResult};
+use thiserror::Error;
+use serde::{Deserialize, Serialize};
+
+/// Main diff engine that orchestrates the comparison process
+pub struct DiffEngine {
+    function_matcher: FunctionMatcher,
+    tree_edit_distance: TreeEditDistance,
+    change_classifier: ChangeClassifier,
+    refactoring_detector: RefactoringDetector,
+}
+
+/// Result of diff computation
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DiffResult {
+    pub match_result: MatchResult,
+    pub refactoring_patterns: Vec<crate::refactoring::RefactoringPattern>,
+    pub execution_time_ms: u64,
+    pub statistics: DiffStatistics,
+}
+
+/// Statistics about the diff computation
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DiffStatistics {
+    pub functions_compared: usize,
+    pub functions_matched: usize,
+    pub functions_added: usize,
+    pub functions_removed: usize,
+    pub functions_modified: usize,
+    pub average_similarity: f64,
+}
+
+/// Diff engine errors
+#[derive(Error, Debug)]
+pub enum DiffError {
+    #[error("Comparison failed: {0}")]
+    ComparisonFailed(String),
+    
+    #[error("Invalid input: {0}")]
+    InvalidInput(String),
+    
+    #[error("Processing error: {0}")]
+    ProcessingError(String),
+}
+
+impl DiffEngine {
+    pub fn new() -> Self {
+        Self {
+            function_matcher: FunctionMatcher::new(0.7),
+            tree_edit_distance: TreeEditDistance::new(EditCost::default()),
+            change_classifier: ChangeClassifier,
+            refactoring_detector: RefactoringDetector::new(),
+        }
+    }
+    
+    /// Compare two sets of functions
+    pub fn compare_functions(&self, source_functions: &[Function], target_functions: &[Function]) -> Result<DiffResult, DiffError> {
+        let start_time = std::time::Instant::now();
+        
+        // Match functions
+        let match_result = self.function_matcher.match_functions(source_functions, target_functions);
+        
+        // Detect refactoring patterns
+        let refactoring_patterns = self.refactoring_detector.detect_patterns(&match_result.changes);
+        
+        // Calculate statistics
+        let statistics = self.calculate_statistics(source_functions, target_functions, &match_result);
+        
+        let execution_time_ms = start_time.elapsed().as_millis() as u64;
+        
+        Ok(DiffResult {
+            match_result,
+            refactoring_patterns,
+            execution_time_ms,
+            statistics,
+        })
+    }
+    
+    fn calculate_statistics(&self, source: &[Function], target: &[Function], match_result: &MatchResult) -> DiffStatistics {
+        let functions_compared = source.len() + target.len();
+        let functions_matched = match_result.mapping.len();
+        let functions_added = match_result.unmatched_target.len();
+        let functions_removed = match_result.unmatched_source.len();
+        let functions_modified = match_result.changes.iter()
+            .filter(|c| matches!(c.change_type, smart_diff_parser::ChangeType::Modify))
+            .count();
+        
+        DiffStatistics {
+            functions_compared,
+            functions_matched,
+            functions_added,
+            functions_removed,
+            functions_modified,
+            average_similarity: match_result.similarity,
+        }
+    }
+}

crates/diff-engine/src/matching.rs

@@ -0,0 +1,197 @@
+//! Function matching algorithms
+
+use smart_diff_parser::{Function, MatchResult};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Function matcher that finds optimal mappings between function sets
+pub struct FunctionMatcher {
+    threshold: f64,
+}
+
+/// Similarity score between two functions
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SimilarityScore {
+    pub signature_similarity: f64,
+    pub body_similarity: f64,
+    pub context_similarity: f64,
+    pub overall_similarity: f64,
+}
+
+impl FunctionMatcher {
+    pub fn new(threshold: f64) -> Self {
+        Self { threshold }
+    }
+    
+    /// Match functions between two sets using Hungarian algorithm
+    pub fn match_functions(&self, source_functions: &[Function], target_functions: &[Function]) -> MatchResult {
+        let mut result = MatchResult::new();
+        
+        if source_functions.is_empty() && target_functions.is_empty() {
+            result.similarity = 1.0;
+            return result;
+        }
+        
+        // Calculate similarity matrix
+        let similarity_matrix = self.calculate_similarity_matrix(source_functions, target_functions);
+        
+        // Apply Hungarian algorithm for optimal matching
+        let matches = self.hungarian_matching(&similarity_matrix);
+        
+        // Process matches and create result
+        self.process_matches(source_functions, target_functions, &matches, &mut result);
+        
+        result.calculate_similarity();
+        result
+    }
+    
+    fn calculate_similarity_matrix(&self, source: &[Function], target: &[Function]) -> Vec<Vec<f64>> {
+        let mut matrix = Vec::new();
+        
+        for source_func in source {
+            let mut row = Vec::new();
+            for target_func in target {
+                let similarity = self.calculate_function_similarity(source_func, target_func);
+                row.push(similarity.overall_similarity);
+            }
+            matrix.push(row);
+        }
+        
+        matrix
+    }
+    
+    /// Calculate similarity between two functions
+    pub fn calculate_function_similarity(&self, func1: &Function, func2: &Function) -> SimilarityScore {
+        // Signature similarity (40% weight)
+        let signature_similarity = func1.signature.similarity(&func2.signature);
+        
+        // Body similarity using AST structure (40% weight)
+        let body_similarity = self.calculate_ast_similarity(&func1.body, &func2.body);
+        
+        // Context similarity (20% weight) - based on surrounding functions, calls, etc.
+        let context_similarity = self.calculate_context_similarity(func1, func2);
+        
+        // Weighted overall similarity
+        let overall_similarity = 
+            signature_similarity * 0.4 + 
+            body_similarity * 0.4 + 
+            context_similarity * 0.2;
+        
+        SimilarityScore {
+            signature_similarity,
+            body_similarity,
+            context_similarity,
+            overall_similarity,
+        }
+    }
+    
+    fn calculate_ast_similarity(&self, ast1: &smart_diff_parser::ASTNode, ast2: &smart_diff_parser::ASTNode) -> f64 {
+        // Simple structural similarity based on node types and tree structure
+        if ast1.node_type != ast2.node_type {
+            return 0.0;
+        }
+        
+        if ast1.children.is_empty() && ast2.children.is_empty() {
+            return 1.0;
+        }
+        
+        if ast1.children.len() != ast2.children.len() {
+            return 0.5; // Partial similarity for different child counts
+        }
+        
+        let mut total_similarity = 0.0;
+        for (child1, child2) in ast1.children.iter().zip(ast2.children.iter()) {
+            total_similarity += self.calculate_ast_similarity(child1, child2);
+        }
+        
+        total_similarity / ast1.children.len() as f64
+    }
+    
+    fn calculate_context_similarity(&self, func1: &Function, func2: &Function) -> f64 {
+        // Compare function calls, dependencies, etc.
+        let calls1 = func1.extract_function_calls();
+        let calls2 = func2.extract_function_calls();
+        
+        if calls1.is_empty() && calls2.is_empty() {
+            return 1.0;
+        }
+        
+        let common_calls = calls1.iter()
+            .filter(|call| calls2.contains(call))
+            .count();
+        
+        let total_calls = calls1.len().max(calls2.len());
+        if total_calls > 0 {
+            common_calls as f64 / total_calls as f64
+        } else {
+            1.0
+        }
+    }
+    
+    fn hungarian_matching(&self, similarity_matrix: &[Vec<f64>]) -> Vec<(usize, usize)> {
+        // Placeholder implementation - in reality would use Hungarian algorithm
+        let mut matches = Vec::new();
+        
+        for (i, row) in similarity_matrix.iter().enumerate() {
+            if let Some((j, &similarity)) = row.iter().enumerate().max_by(|a, b| a.1.partial_cmp(b.1).unwrap()) {
+                if similarity >= self.threshold {
+                    matches.push((i, j));
+                }
+            }
+        }
+        
+        matches
+    }
+    
+    fn process_matches(&self, source: &[Function], target: &[Function], 
+                      matches: &[(usize, usize)], result: &mut MatchResult) {
+        let mut matched_source = std::collections::HashSet::new();
+        let mut matched_target = std::collections::HashSet::new();
+        
+        for &(source_idx, target_idx) in matches {
+            let source_func = &source[source_idx];
+            let target_func = &target[target_idx];
+            
+            result.mapping.insert(source_func.hash.clone(), target_func.hash.clone());
+            matched_source.insert(source_idx);
+            matched_target.insert(target_idx);
+            
+            // Create change record if functions are different
+            let similarity = self.calculate_function_similarity(source_func, target_func);
+            if similarity.overall_similarity < 1.0 {
+                let change = smart_diff_parser::Change::new(
+                    smart_diff_parser::ChangeType::Modify,
+                    format!("Function '{}' modified (similarity: {:.2})", 
+                           source_func.signature.name, similarity.overall_similarity)
+                ).with_confidence(similarity.overall_similarity);
+                
+                result.changes.push(change);
+            }
+        }
+        
+        // Record unmatched functions
+        for (i, func) in source.iter().enumerate() {
+            if !matched_source.contains(&i) {
+                result.unmatched_source.push(func.hash.clone());
+                
+                let change = smart_diff_parser::Change::new(
+                    smart_diff_parser::ChangeType::Delete,
+                    format!("Function '{}' deleted", func.signature.name)
+                );
+                result.changes.push(change);
+            }
+        }
+        
+        for (i, func) in target.iter().enumerate() {
+            if !matched_target.contains(&i) {
+                result.unmatched_target.push(func.hash.clone());
+                
+                let change = smart_diff_parser::Change::new(
+                    smart_diff_parser::ChangeType::Add,
+                    format!("Function '{}' added", func.signature.name)
+                );
+                result.changes.push(change);
+            }
+        }
+    }
+}