Fixing test errors

Author: matteius

crates/parser/src/ast.rs

@@ -81,6 +81,12 @@ pub enum NodeType {
     Unknown,
 }
 
+impl std::fmt::Display for NodeType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 /// Metadata associated with an AST node
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct NodeMetadata {

crates/parser/src/ast_processor.rs

@@ -439,7 +439,7 @@ pub struct Symbol {
 }
 
 /// Types of symbols
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum SymbolType {
     Function,
     Class,

crates/semantic-analysis/src/analyzer.rs

@@ -39,6 +39,12 @@ pub enum AnalysisError {
     AnalysisFailed(String),
 }
 
+impl Default for SemanticAnalyzer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl SemanticAnalyzer {
     pub fn new() -> Self {
         Self {

crates/semantic-analysis/src/comprehensive_dependency_graph.rs

@@ -239,7 +239,7 @@ impl ComprehensiveDependencyGraphBuilder {
     ) -> Result<FileAnalysisContext> {
         let mut context = FileAnalysisContext {
             file_path: file_path.to_string(),
-            language: parse_result.language.clone(),
+            language: parse_result.language,
             functions: Vec::new(),
             classes: Vec::new(),
             variables: Vec::new(),
@@ -520,6 +520,7 @@ impl ComprehensiveDependencyGraphBuilder {
         calls
     }
 
+    #[allow(clippy::only_used_in_recursion)]
     fn collect_function_calls_recursive(&self, node: &ASTNode, calls: &mut Vec<String>) {
         if node.node_type == NodeType::CallExpression {
             if let Some(function_name) = node.metadata.attributes.get("function_name") {
@@ -538,6 +539,7 @@ impl ComprehensiveDependencyGraphBuilder {
         accesses
     }
 
+    #[allow(clippy::only_used_in_recursion)]
     fn collect_variable_accesses_recursive(&self, node: &ASTNode, accesses: &mut Vec<String>) {
         if matches!(
             node.node_type,
@@ -705,7 +707,7 @@ impl ComprehensiveDependencyGraphBuilder {
 
     /// Create type dependency edges
     fn create_type_dependency_edges(&mut self) -> Result<()> {
-        for (_file_path, type_result) in &self.type_extraction_results {
+        for type_result in self.type_extraction_results.values() {
             for extracted_type in &type_result.types {
                 let type_name = &extracted_type.type_info.name;
 
@@ -735,18 +737,17 @@ impl ComprehensiveDependencyGraphBuilder {
 
                 // Field type dependencies
                 for field in &extracted_type.type_info.fields {
-                    if !self.is_primitive_type(&field.type_name) {
-                        if self.node_map.contains_key(type_name)
-                            && self.node_map.contains_key(&field.type_name)
-                        {
-                            let strength = if field.is_static { 0.6 } else { 0.8 };
-                            let edge = DependencyEdge {
-                                edge_type: DependencyEdgeType::Uses,
-                                strength,
-                            };
-                            self.dependency_graph
-                                .add_edge(type_name, &field.type_name, edge);
-                        }
+                    if !self.is_primitive_type(&field.type_name)
+                        && self.node_map.contains_key(type_name)
+                        && self.node_map.contains_key(&field.type_name)
+                    {
+                        let strength = if field.is_static { 0.6 } else { 0.8 };
+                        let edge = DependencyEdge {
+                            edge_type: DependencyEdgeType::Uses,
+                            strength,
+                        };
+                        self.dependency_graph
+                            .add_edge(type_name, &field.type_name, edge);
                     }
                 }
             }
@@ -1016,15 +1017,11 @@ impl ComprehensiveDependencyGraphBuilder {
             .iter()
             .filter(|dep| {
                 // Check if dependency is a variable or field
-                if let Some(_context) = self.file_contexts.values().find(|ctx| {
+                matches!(self.file_contexts.values().find(|ctx| {
                     ctx.variables
                         .iter()
-                        .any(|var| &var.qualified_name == &dep.id)
-                }) {
-                    true
-                } else {
-                    false
-                }
+                        .any(|var| var.qualified_name == dep.id)
+                }), Some(_context))
             })
             .count()
     }

crates/semantic-analysis/src/dependency_graph.rs

@@ -50,6 +50,12 @@ pub enum DependencyEdgeType {
     Contains,
 }
 
+impl Default for DependencyGraph {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl DependencyGraph {
     pub fn new() -> Self {
         Self {

crates/semantic-analysis/src/function_signature_extractor.rs

@@ -222,7 +222,7 @@ impl FunctionSignatureExtractor {
             // Group overloaded functions
             overloaded_functions
                 .entry(signature.name.clone())
-                .or_insert_with(Vec::new)
+                .or_default()
                 .push(signature.clone());
         }
 
@@ -262,7 +262,7 @@ impl FunctionSignatureExtractor {
             for (name, overloads) in file_result.overloaded_functions {
                 overloaded_functions
                     .entry(name)
-                    .or_insert_with(Vec::new)
+                    .or_default()
                     .extend(overloads);
             }
 
@@ -449,8 +449,8 @@ impl FunctionSignatureExtractor {
 
         // Check if optional or varargs
         let is_optional =
-            node.metadata.attributes.get("optional").is_some() || default_value.is_some();
-        let is_varargs = node.metadata.attributes.get("varargs").is_some();
+            node.metadata.attributes.contains_key("optional") || default_value.is_some();
+        let is_varargs = node.metadata.attributes.contains_key("varargs");
 
         // Extract annotations
         let annotations = self.extract_parameter_annotations(node);
@@ -588,7 +588,7 @@ impl FunctionSignatureExtractor {
         match node.node_type {
             NodeType::Constructor => FunctionType::Constructor,
             NodeType::Method => {
-                if node.metadata.attributes.get("static").is_some() {
+                if node.metadata.attributes.contains_key("static") {
                     FunctionType::StaticMethod
                 } else if name.starts_with("get") && name.len() > 3 {
                     FunctionType::Getter
@@ -659,6 +659,8 @@ impl FunctionSignatureExtractor {
     }
 
     /// Recursively calculate complexity metrics
+    #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::only_used_in_recursion)]
     fn calculate_complexity_recursive(
         &self,
         node: &ASTNode,
@@ -748,6 +750,7 @@ impl FunctionSignatureExtractor {
     }
 
     /// Recursively extract function call dependencies
+    #[allow(clippy::only_used_in_recursion)]
     fn extract_dependencies_recursive(&self, node: &ASTNode, dependencies: &mut Vec<String>) {
         if node.node_type == NodeType::CallExpression {
             if let Some(function_name) = node.metadata.attributes.get("function_name") {
@@ -876,7 +879,7 @@ impl FunctionSignatureExtractor {
 
             class_functions
                 .entry(class_name)
-                .or_insert_with(Vec::new)
+                .or_default()
                 .push(signature);
         }
 

crates/semantic-analysis/src/scope_manager.rs

@@ -245,8 +245,10 @@ impl ScopeManager {
 
     /// Analyze scope structure
     pub fn analyze_scopes(&self) -> ScopeAnalysis {
-        let mut analysis = ScopeAnalysis::default();
-        analysis.total_scopes = self.scopes.len();
+        let mut analysis = ScopeAnalysis {
+            total_scopes: self.scopes.len(),
+            ..Default::default()
+        };
 
         let mut total_symbols = 0;
         let mut max_depth = 0;

crates/semantic-analysis/src/symbol_resolver.rs

@@ -92,7 +92,7 @@ impl SymbolResolver {
     pub fn process_file(&mut self, file_path: &str, parse_result: &ParseResult) -> Result<()> {
         let mut file_context = FileContext {
             file_path: file_path.to_string(),
-            language: parse_result.language.clone(),
+            language: parse_result.language,
             imports: Vec::new(),
             exports: Vec::new(),
             local_scope_stack: Vec::new(),
@@ -138,18 +138,15 @@ impl SymbolResolver {
 
     /// Extract import statements from AST
     fn extract_imports(&mut self, node: &ASTNode, file_context: &mut FileContext) -> Result<()> {
-        match node.node_type {
-            NodeType::Module => {
-                // Handle different import patterns based on language
-                match file_context.language {
-                    Language::Java => self.extract_java_imports(node, file_context)?,
-                    Language::Python => self.extract_python_imports(node, file_context)?,
-                    Language::JavaScript => self.extract_js_imports(node, file_context)?,
-                    Language::Cpp | Language::C => self.extract_c_includes(node, file_context)?,
-                    _ => {}
-                }
+        if node.node_type == NodeType::Module {
+            // Handle different import patterns based on language
+            match file_context.language {
+                Language::Java => self.extract_java_imports(node, file_context)?,
+                Language::Python => self.extract_python_imports(node, file_context)?,
+                Language::JavaScript => self.extract_js_imports(node, file_context)?,
+                Language::Cpp | Language::C => self.extract_c_includes(node, file_context)?,
+                _ => {}
             }
-            _ => {}
         }
 
         // Recursively process children
@@ -503,7 +500,6 @@ impl SymbolResolver {
                     // Try to extract variable name
                     let var_name = if let Some(eq_pos) = trimmed.find('=') {
                         trimmed[..eq_pos]
-                            .trim()
                             .split_whitespace()
                             .last()
                             .unwrap_or("unknown")
@@ -539,8 +535,8 @@ impl SymbolResolver {
     ) -> Result<ImportInfo> {
         let trimmed = include_text.trim();
 
-        if trimmed.starts_with("#include") {
-            let include_part = trimmed[8..].trim(); // Skip "#include"
+        if let Some(stripped) = trimmed.strip_prefix("#include") {
+            let include_part = stripped.trim();
 
             let (header_name, is_system) =
                 if include_part.starts_with('<') && include_part.ends_with('>') {

crates/semantic-analysis/src/symbol_table.rs

@@ -90,6 +90,12 @@ pub enum ReferenceType {
     Assignment,
 }
 
+impl Default for SymbolTable {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl SymbolTable {
     pub fn new() -> Self {
         Self {
@@ -139,7 +145,7 @@ impl SymbolTable {
         // Add to file symbols
         self.file_symbols
             .entry(symbol.file_path.clone())
-            .or_insert_with(HashMap::new)
+            .or_default()
             .insert(name.clone(), symbol.clone());
 
         // Add to global symbols if it's a global symbol