Fixing build errors

Author: matteius

crates/cli/src/cli.rs

@@ -60,7 +60,7 @@ pub enum Commands {
     },
 }
 
-#[derive(clap::ValueEnum, Clone)]
+#[derive(clap::ValueEnum, Clone, Debug)]
 pub enum OutputFormat {
     Text,
     Json,

crates/cli/src/output.rs

@@ -3,9 +3,11 @@
 use colored::*;
 use serde_json;
 
+#[allow(dead_code)]
 pub struct OutputFormatter;
 
 impl OutputFormatter {
+    #[allow(dead_code)]
     pub fn format_diff_text(changes: &[String]) -> String {
         let mut output = String::new();
 
@@ -22,10 +24,12 @@ impl OutputFormatter {
         output
     }
 
+    #[allow(dead_code)]
     pub fn format_diff_json(changes: &[String]) -> Result<String, serde_json::Error> {
         serde_json::to_string_pretty(changes)
     }
 
+    #[allow(dead_code)]
     pub fn format_diff_html(changes: &[String]) -> String {
         let mut html = String::from("<div class=\"diff\">\n");
 

crates/diff-engine/src/changes.rs

@@ -1,7 +1,6 @@
 //! Change classification and analysis
 
-use serde::{Deserialize, Serialize};
-use smart_diff_parser::{Change, ChangeType, CodeElement};
+use smart_diff_parser::{ChangeType, CodeElement};
 
 /// Change classifier that categorizes detected changes
 pub struct ChangeClassifier;

crates/diff-engine/src/engine.rs

@@ -11,7 +11,9 @@ use thiserror::Error;
 /// Main diff engine that orchestrates the comparison process
 pub struct DiffEngine {
     function_matcher: FunctionMatcher,
+    #[allow(dead_code)]
     tree_edit_distance: TreeEditDistance,
+    #[allow(dead_code)]
     change_classifier: ChangeClassifier,
     refactoring_detector: RefactoringDetector,
 }

crates/diff-engine/src/lib.rs

@@ -11,16 +11,16 @@ pub mod similarity_scorer;
 pub mod tree_edit;
 
 pub use changes::ChangeClassifier;
-pub use smart_diff_parser::{Change, ChangeType};
 pub use engine::{DiffEngine, DiffError, DiffResult};
 pub use matching::{FunctionMatcher, SimilarityScore};
-pub use smart_diff_parser::MatchResult;
 pub use refactoring::{RefactoringDetector, RefactoringPattern};
 pub use similarity_scorer::{
     ASTSimilarityScore, ComprehensiveSimilarityScore, ContextSimilarityScore,
     DetailedSimilarityBreakdown, MatchType, SemanticSimilarityMetrics, SimilarityFactor,
     SimilarityScorer, SimilarityScoringConfig,
 };
+pub use smart_diff_parser::MatchResult;
+pub use smart_diff_parser::{Change, ChangeType};
 pub use tree_edit::{EditCost, EditOperation, TreeEditDistance};
 
 /// Re-export commonly used types

crates/diff-engine/src/matching.rs

@@ -2,7 +2,6 @@
 
 use serde::{Deserialize, Serialize};
 use smart_diff_parser::{Function, MatchResult};
-use std::collections::HashMap;
 
 /// Function matcher that finds optimal mappings between function sets
 pub struct FunctionMatcher {

crates/diff-engine/src/refactoring.rs

@@ -36,17 +36,17 @@ impl RefactoringDetector {
         patterns
     }
 
-    fn detect_extract_method(&self, changes: &[Change]) -> Vec<RefactoringPattern> {
+    fn detect_extract_method(&self, _changes: &[Change]) -> Vec<RefactoringPattern> {
         // Look for patterns where code is removed from one function and added to a new function
         Vec::new() // Placeholder
     }
 
-    fn detect_rename_patterns(&self, changes: &[Change]) -> Vec<RefactoringPattern> {
+    fn detect_rename_patterns(&self, _changes: &[Change]) -> Vec<RefactoringPattern> {
         // Look for rename patterns
         Vec::new() // Placeholder
     }
 
-    fn detect_move_patterns(&self, changes: &[Change]) -> Vec<RefactoringPattern> {
+    fn detect_move_patterns(&self, _changes: &[Change]) -> Vec<RefactoringPattern> {
         // Look for move patterns
         Vec::new() // Placeholder
     }

crates/diff-engine/src/similarity_scorer.rs

@@ -6,7 +6,6 @@ use serde::{Deserialize, Serialize};
 use smart_diff_parser::{ASTNode, Language, NodeType};
 use smart_diff_semantic::{
     EnhancedFunctionSignature, FunctionSignatureExtractor, FunctionSignatureSimilarity,
-    TypeEquivalence,
 };
 use std::collections::{HashMap, HashSet};
 
@@ -52,6 +51,7 @@ impl Default for SimilarityScoringConfig {
 /// Comprehensive similarity scorer
 pub struct SimilarityScorer {
     config: SimilarityScoringConfig,
+    #[allow(dead_code)]
     language: Language,
     signature_extractor: FunctionSignatureExtractor,
     tree_edit_calculator: TreeEditDistance,
@@ -190,6 +190,7 @@ struct ContextInfo {
     function_calls: HashSet<String>,
     variable_names: HashSet<String>,
     type_usage: HashSet<String>,
+    #[allow(dead_code)]
     control_flow_patterns: Vec<String>,
     dependencies: HashSet<String>,
 }
@@ -601,7 +602,7 @@ impl SimilarityScorer {
             self.calculate_set_similarity(&context1.dependencies, &context2.dependencies);
 
         // Type usage similarity
-        let type_usage_similarity =
+        let _type_usage_similarity =
             self.calculate_set_similarity(&context1.type_usage, &context2.type_usage);
 
         // Surrounding code similarity (based on class/namespace context)
@@ -1115,9 +1116,9 @@ impl SimilarityScorer {
         context_similarity: &ContextSimilarityScore,
     ) -> f64 {
         // Base confidence from overall similarities
-        let base_confidence = (signature_similarity.overall_similarity * 0.4
+        let base_confidence = signature_similarity.overall_similarity * 0.4
             + body_similarity.overall_similarity * 0.4
-            + context_similarity.overall_similarity * 0.2);
+            + context_similarity.overall_similarity * 0.2;
 
         // Boost confidence for exact matches
         let exact_match_bonus = if signature_similarity.similarity_breakdown.exact_name_match {
@@ -1153,9 +1154,9 @@ impl SimilarityScorer {
     /// Build detailed similarity breakdown
     fn build_detailed_breakdown(
         &self,
-        func1_signature: &EnhancedFunctionSignature,
+        _func1_signature: &EnhancedFunctionSignature,
         func1_ast: &ASTNode,
-        func2_signature: &EnhancedFunctionSignature,
+        _func2_signature: &EnhancedFunctionSignature,
         func2_ast: &ASTNode,
         signature_similarity: &FunctionSignatureSimilarity,
         body_similarity: &ASTSimilarityScore,

crates/diff-engine/src/tree_edit.rs

@@ -81,7 +81,7 @@ impl TreeEditDistance {
     }
 
     /// Calculate edit operations to transform tree1 into tree2
-    pub fn calculate_operations(&self, tree1: &ASTNode, tree2: &ASTNode) -> Vec<EditOperation> {
+    pub fn calculate_operations(&self, _tree1: &ASTNode, _tree2: &ASTNode) -> Vec<EditOperation> {
         // Placeholder implementation
         // Would return the sequence of operations needed for transformation
         Vec::new()

crates/semantic-analysis/src/analyzer.rs

@@ -51,7 +51,7 @@ impl SemanticAnalyzer {
     /// Analyze a parsed file
     pub fn analyze(&mut self, parse_result: &ParseResult) -> Result<AnalysisResult, AnalysisError> {
         let mut errors = Vec::new();
-        let mut warnings = Vec::new();
+        let warnings = Vec::new();
 
         // First pass: collect symbols and types
         if let Err(e) = self.collect_symbols(&parse_result.ast, &parse_result.language.to_string())
@@ -78,19 +78,19 @@ impl SemanticAnalyzer {
         })
     }
 
-    fn collect_symbols(&mut self, ast: &ASTNode, file_path: &str) -> Result<(), AnalysisError> {
+    fn collect_symbols(&mut self, _ast: &ASTNode, _file_path: &str) -> Result<(), AnalysisError> {
         // TODO: Implement symbol collection
         // This would traverse the AST and populate the symbol table
         Ok(())
     }
 
-    fn resolve_references(&mut self, ast: &ASTNode) -> Result<(), AnalysisError> {
+    fn resolve_references(&mut self, _ast: &ASTNode) -> Result<(), AnalysisError> {
         // TODO: Implement reference resolution
         // This would find all symbol references and link them to declarations
         Ok(())
     }
 
-    fn check_types(&mut self, ast: &ASTNode) -> Result<(), AnalysisError> {
+    fn check_types(&mut self, _ast: &ASTNode) -> Result<(), AnalysisError> {
         // TODO: Implement type checking
         // This would verify type compatibility and catch type errors
         Ok(())