Check pt fixing errors

Author: matteius

crates/cli/src/output.rs

@@ -437,7 +437,7 @@ impl OutputFormatter {
     }
 
     /// Format as JSON
-    fn format_json(results: &[ComparisonResult], stats: Option<&ComparisonStats>) -> Result<String> {
+    fn format_json(_results: &[ComparisonResult], _stats: Option<&ComparisonStats>) -> Result<String> {
         // JSON serialization disabled due to non-serializable types
         let _output = "JSON output not yet supported for comparison results";
 

crates/diff-engine/src/changes.rs

@@ -641,8 +641,8 @@ impl ChangeClassifier {
         source: &CodeElement,
         target: &CodeElement,
         similarity_metrics: &Option<ComprehensiveSimilarityScore>,
-        source_signature: Option<&EnhancedFunctionSignature>,
-        target_signature: Option<&EnhancedFunctionSignature>,
+        _source_signature: Option<&EnhancedFunctionSignature>,
+        _target_signature: Option<&EnhancedFunctionSignature>,
     ) -> (ChangeType, f64) {
         // Check for cross-file move first
         if source.file_path != target.file_path {

crates/diff-engine/src/cross_file_tracker.rs

@@ -633,8 +633,8 @@ impl CrossFileTracker {
     /// Calculate confidence for rename+move detection
     fn calculate_rename_move_confidence(
         &self,
-        source_sig: &EnhancedFunctionSignature,
-        target_sig: &EnhancedFunctionSignature,
+        _source_sig: &EnhancedFunctionSignature,
+        _target_sig: &EnhancedFunctionSignature,
         source_file: &str,
         target_file: &str,
         similarity: &ComprehensiveSimilarityScore,
@@ -794,9 +794,9 @@ impl CrossFileTracker {
     /// Check if a symbol is referenced across files using global symbol table
     fn is_symbol_referenced_across_files(
         &self,
-        resolver: &SymbolResolver,
-        symbol_name: &str,
-        target_file: &str,
+        _resolver: &SymbolResolver,
+        _symbol_name: &str,
+        _target_file: &str,
     ) -> bool {
         // This would use the symbol resolver to check cross-file references
         // For now, return false as a placeholder

crates/diff-engine/src/refactoring.rs

@@ -1088,7 +1088,7 @@ impl RefactoringDetector {
     /// Calculate detailed confidence for extract method pattern
     fn calculate_detailed_extract_method_confidence(
         &mut self,
-        modified: &Change,
+        _modified: &Change,
         added: &Change,
         source_ast: Option<&ASTNode>,
         target_ast: Option<&ASTNode>,
@@ -1166,8 +1166,8 @@ impl RefactoringDetector {
     fn detect_inline_method_detailed(
         &self,
         change_groups: &[Vec<&Change>],
-        source_asts: &HashMap<String, ASTNode>,
-        target_asts: &HashMap<String, ASTNode>,
+        _source_asts: &HashMap<String, ASTNode>,
+        _target_asts: &HashMap<String, ASTNode>,
         source_signatures: &HashMap<String, EnhancedFunctionSignature>,
         target_signatures: &HashMap<String, EnhancedFunctionSignature>,
     ) -> Result<Vec<RefactoringPattern>> {
@@ -1383,8 +1383,8 @@ impl RefactoringDetector {
     fn detect_move_patterns_detailed(
         &self,
         change_groups: &[Vec<&Change>],
-        source_asts: &HashMap<String, ASTNode>,
-        target_asts: &HashMap<String, ASTNode>,
+        _source_asts: &HashMap<String, ASTNode>,
+        _target_asts: &HashMap<String, ASTNode>,
         source_signatures: &HashMap<String, EnhancedFunctionSignature>,
         target_signatures: &HashMap<String, EnhancedFunctionSignature>,
     ) -> Result<Vec<RefactoringPattern>> {
@@ -1682,7 +1682,7 @@ impl RefactoringDetector {
     }
 
     /// Gather inline method evidence
-    fn gather_inline_method_evidence(&self, deleted: &Change, modified: &Change) -> Vec<RefactoringEvidence> {
+    fn gather_inline_method_evidence(&self, deleted: &Change, _modified: &Change) -> Vec<RefactoringEvidence> {
         let mut evidence = Vec::new();
 
         evidence.push(RefactoringEvidence {

crates/diff-engine/src/tree_edit.rs

@@ -462,7 +462,7 @@ impl TreeEditDistance {
     }
 
     /// Calculate edit operations using Zhang-Shasha with backtracking
-    fn zhang_shasha_operations(&self, tree1_info: &TreeInfo, tree2_info: &TreeInfo, tree1: &ASTNode, tree2: &ASTNode) -> Vec<EditOperation> {
+    fn zhang_shasha_operations(&self, _tree1_info: &TreeInfo, _tree2_info: &TreeInfo, tree1: &ASTNode, tree2: &ASTNode) -> Vec<EditOperation> {
         // This is a simplified implementation - full backtracking would be more complex
         let mut operations = Vec::new();
 

crates/web-ui/src/handlers.rs

@@ -5,12 +5,12 @@ use axum::{
     http::StatusCode,
     response::{Html, Json as ResponseJson},
 };
-use serde_json::{json, Value};
+use serde_json::json;
 use std::collections::HashMap;
 use std::time::{Instant, SystemTime, UNIX_EPOCH};
 
-use smart_diff_parser::{LanguageDetector, ParserEngine};
-use smart_diff_semantic::{SemanticAnalyzer, SymbolResolver};
+use smart_diff_parser::{LanguageDetector, tree_sitter::TreeSitterParser, Parser, Language};
+use smart_diff_semantic::{SemanticAnalyzer};
 use smart_diff_engine::{
     DiffEngine, FunctionMatcher, SimilarityScorer, ChangeClassifier, RefactoringDetector,
 };
@@ -148,44 +148,54 @@ async fn perform_comparison(
     options: &CompareOptions,
 ) -> anyhow::Result<AnalysisResult> {
     // Initialize components
-    let language_detector = LanguageDetector::new();
-    let parser_engine = ParserEngine::new();
+    let language_detector = LanguageDetector;
+    let parser_engine = TreeSitterParser::new()?;
     let semantic_analyzer = SemanticAnalyzer::new();
     let diff_engine = DiffEngine::new();
-    let function_matcher = FunctionMatcher::new();
-    let similarity_scorer = SimilarityScorer::new();
-    let change_classifier = ChangeClassifier::new();
-    let refactoring_detector = RefactoringDetector::new();
 
     // Detect language
-    let language = language_detector.detect_language(&file1.path, &file1.content)?;
+    let language = language_detector.detect_from_path(&file1.path)
+        .or_else(|| language_detector.detect_from_content(&file1.content))
+        .unwrap_or(Language::Unknown);
 
     // Parse both files
-    let ast1 = parser_engine.parse(&file1.content, &language)?;
-    let ast2 = parser_engine.parse(&file2.content, &language)?;
+    let parse_result1 = parser_engine.parse(&file1.content, language)?;
+    let parse_result2 = parser_engine.parse(&file2.content, language)?;
+    let ast1 = parse_result1.ast;
+    let ast2 = parse_result2.ast;
 
     // Perform semantic analysis
-    let semantic1 = semantic_analyzer.analyze(&ast1)?;
-    let semantic2 = semantic_analyzer.analyze(&ast2)?;
+    let semantic1 = semantic_analyzer.analyze(&parse_result1)?;
+    let semantic2 = semantic_analyzer.analyze(&parse_result2)?;
 
-    // Extract functions
-    let functions1 = semantic1.extract_functions();
-    let functions2 = semantic2.extract_functions();
+    // Initialize components that need language
+    let function_matcher = FunctionMatcher::new(0.7); // threshold
+    let similarity_scorer = SimilarityScorer::new(language, smart_diff_engine::SimilarityScoringConfig::default());
+    let change_classifier = ChangeClassifier::new(language);
+    let refactoring_detector = RefactoringDetector::new(language);
+
+    // Extract functions from symbol tables
+    let functions1 = extract_functions_from_symbol_table(&semantic1.symbol_table);
+    let functions2 = extract_functions_from_symbol_table(&semantic2.symbol_table);
 
     // Match functions
-    let function_matches = function_matcher.match_functions(&functions1, &functions2)?;
+    let function_matches = function_matcher.match_functions(&functions1, &functions2);
 
-    // Calculate similarity scores
-    let overall_similarity = similarity_scorer.calculate_similarity(&ast1, &ast2)?;
-    let structure_similarity = similarity_scorer.calculate_structure_similarity(&ast1, &ast2)?;
-    let content_similarity = similarity_scorer.calculate_content_similarity(&file1.content, &file2.content)?;
-    let semantic_similarity = similarity_scorer.calculate_semantic_similarity(&semantic1, &semantic2)?;
+    // Calculate basic similarity scores (simplified for web API)
+    let overall_similarity = if !functions1.is_empty() && !functions2.is_empty() {
+        function_matches.similarity
+    } else {
+        0.0
+    };
+    let structure_similarity = overall_similarity; // Simplified
+    let content_similarity = overall_similarity; // Simplified
+    let semantic_similarity = overall_similarity; // Simplified
 
-    // Classify changes
-    let changes = change_classifier.classify_changes(&function_matches)?;
+    // Use changes from function matching
+    let changes = function_matches.changes;
 
     // Detect refactoring patterns
-    let refactoring_patterns = refactoring_detector.detect_patterns(&changes)?;
+    let refactoring_patterns = refactoring_detector.detect_patterns(&changes);
 
     // Build response
     let analysis = AnalysisResult {
@@ -194,15 +204,15 @@ async fn perform_comparison(
                 path: file1.path.clone(),
                 lines: file1.content.lines().count(),
                 functions: functions1.len(),
-                classes: semantic1.extract_classes().len(),
-                complexity: semantic1.calculate_complexity(),
+                classes: count_classes_from_symbol_table(&semantic1.symbol_table),
+                complexity: calculate_complexity_from_symbol_table(&semantic1.symbol_table),
             },
             target: FileMetadata {
                 path: file2.path.clone(),
                 lines: file2.content.lines().count(),
                 functions: functions2.len(),
-                classes: semantic2.extract_classes().len(),
-                complexity: semantic2.calculate_complexity(),
+                classes: count_classes_from_symbol_table(&semantic2.symbol_table),
+                complexity: calculate_complexity_from_symbol_table(&semantic2.symbol_table),
             },
             language: language.to_string(),
             similarity: SimilarityScore {
@@ -411,23 +421,25 @@ async fn perform_multi_file_analysis(
     files: &[FileInfo],
     options: &AnalyzeOptions,
 ) -> anyhow::Result<MultiFileAnalysisResult> {
-    let language_detector = LanguageDetector::new();
-    let parser_engine = ParserEngine::new();
-    let semantic_analyzer = SemanticAnalyzer::new();
+    let language_detector = LanguageDetector;
+    let parser_engine = TreeSitterParser::new()?;
+    let mut semantic_analyzer = SemanticAnalyzer::new();
 
     let mut file_results = Vec::new();
     let mut all_functions = Vec::new();
     let mut total_complexity = 0.0;
 
     // Analyze each file
     for file in files {
-        let language = language_detector.detect_language(&file.path, &file.content)?;
-        let ast = parser_engine.parse(&file.content, &language)?;
-        let semantic = semantic_analyzer.analyze(&ast)?;
+        let language = language_detector.detect_from_path(&file.path)
+            .or_else(|| language_detector.detect_from_content(&file.content))
+            .unwrap_or(Language::Unknown);
+        let parse_result = parser_engine.parse(&file.content, language)?;
+        let semantic = semantic_analyzer.analyze(&parse_result)?;
 
-        let functions = semantic.extract_functions();
-        let complexity = semantic.calculate_complexity();
-        total_complexity += complexity;
+        let functions = extract_functions_from_symbol_table(&semantic.symbol_table);
+        let complexity = calculate_complexity_from_symbol_table(&semantic.symbol_table);
+        total_complexity += complexity as f64;
 
         let function_infos: Vec<FunctionInfo> = functions.iter().map(|f| FunctionInfo {
             name: f.name.clone(),
@@ -625,3 +637,61 @@ fn calculate_duplicate_rate(
 
     duplicate_count as f64 / all_functions.len() as f64
 }
+
+/// Extract functions from symbol table
+fn extract_functions_from_symbol_table(symbol_table: &smart_diff_semantic::SymbolTable) -> Vec<smart_diff_parser::Function> {
+    use smart_diff_parser::{Function, FunctionSignature, Type, FunctionLocation};
+    use smart_diff_semantic::SymbolKind;
+
+    let mut functions = Vec::new();
+    let function_symbols = symbol_table.get_symbols_by_kind(SymbolKind::Function);
+    let method_symbols = symbol_table.get_symbols_by_kind(SymbolKind::Method);
+
+    for symbol in function_symbols.iter().chain(method_symbols.iter()) {
+        let signature = FunctionSignature {
+            name: symbol.name.clone(),
+            parameters: Vec::new(), // Simplified
+            return_type: Some(Type::new("void".to_string())),
+            modifiers: Vec::new(),
+            generic_parameters: Vec::new(),
+        };
+
+        let location = FunctionLocation {
+            file_path: "".to_string(),
+            start_line: 0,
+            end_line: 0,
+            start_column: 0,
+            end_column: 0,
+        };
+
+        // Create a simple AST node for the function body
+        let body = smart_diff_parser::ASTNode::new(
+            smart_diff_parser::NodeType::Function,
+            smart_diff_parser::ASTMetadata::default(),
+        );
+
+        let function = Function {
+            signature,
+            body,
+            location,
+            dependencies: Vec::new(),
+            hash: format!("hash_{}", symbol.name),
+        };
+
+        functions.push(function);
+    }
+
+    functions
+}
+
+/// Count classes from symbol table
+fn count_classes_from_symbol_table(symbol_table: &smart_diff_semantic::SymbolTable) -> usize {
+    use smart_diff_semantic::SymbolKind;
+    symbol_table.get_symbols_by_kind(SymbolKind::Class).len()
+}
+
+/// Calculate complexity from symbol table
+fn calculate_complexity_from_symbol_table(_symbol_table: &smart_diff_semantic::SymbolTable) -> usize {
+    // Simplified complexity calculation
+    10 // Placeholder value
+}