fixs

Author: AviAvni

api/analyzers/java/analyzer.py

@@ -38,14 +38,7 @@ def get_entity_docstring(self, node: Node) -> Optional[str]:
             if node.prev_sibling.type == "block_comment":
                 return node.prev_sibling.text.decode('utf-8')
             return None
-        raise ValueError(f"Unknown entity type: {node.type}")
-    
-    def find_calls(self, method: Entity):
-        query = self.language.query("(method_invocation) @reference.call")
-        captures = query.captures(method.node)
-        if 'reference.call' in captures:
-            for caller in captures['reference.call']:
-                method.add_symbol("call", caller)
+        raise ValueError(f"Unknown entity type: {node.type}")        
 
     def get_entity_types(self) -> list[str]:
         return ['class_declaration', 'interface_declaration', 'enum_declaration', 'method_declaration', 'constructor_declaration']
@@ -69,7 +62,18 @@ def add_symbols(self, entity: Entity) -> None:
                 for interface in extends_captures['type']:
                     entity.add_symbol("extend_interface", interface)
         elif entity.node.type in ['method_declaration', 'constructor_declaration']:
-            self.find_calls(entity)
+            query = self.language.query("(method_invocation) @reference.call")
+            captures = query.captures(entity.node)
+            if 'reference.call' in captures:
+                for caller in captures['reference.call']:
+                    entity.add_symbol("call", caller)
+            if entity.node.type == 'method_declaration':
+                query = self.language.query("(formal_parameters (formal_parameter type: (_) @parameter))")
+                captures = query.captures(entity.node)
+                if 'parameter' in captures:
+                    for parameter in captures['parameter']:
+                        entity.add_symbol("parameters", parameter)
+                entity.add_symbol("return_type", entity.node.child_by_field_name('type'))
 
     def resolve_type(self, files: dict[Path, File], lsp: SyncLanguageServer, path: Path, node: Node) -> list[Entity]:
         res = []
@@ -85,8 +89,8 @@ def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, path:
             method_dec = self.find_parent(resolved_node, ['method_declaration', 'constructor_declaration', 'class_declaration', 'interface_declaration', 'enum_declaration'])
             if method_dec.type in ['class_declaration', 'interface_declaration', 'enum_declaration']:
                 continue
-            type_dec = self.find_parent(method_dec, ['class_declaration', 'interface_declaration', 'enum_declaration'])
-            res.append(file.entities[type_dec].children[method_dec])
+            if method_dec in file.entities:
+                res.append(file.entities[method_dec])
         return res
 
     def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, path: Path, key: str, symbol: Node) -> Entity:

api/analyzers/source_analyzer.py

@@ -48,7 +48,7 @@ def create_entity_hierarchy(self, entity: Entity, file: File, analyzer: Abstract
                 child = Entity(node)
                 child.id = graph.add_entity(analyzer.get_entity_label(node), analyzer.get_entity_name(node), analyzer.get_entity_docstring(node), str(file.path), node.start_point.row, node.end_point.row, {})
                 analyzer.add_symbols(child)
-                file.add_entity(entity)
+                file.add_entity(child)
                 entity.add_child(child)
                 graph.connect_entities("DEFINES", entity.id, child.id)
                 self.create_entity_hierarchy(child, file, analyzer, graph)
@@ -142,16 +142,12 @@ def second_pass(self, graph: Graph, path: Path) -> None:
                                 graph.connect_entities("IMPLEMENTS", entity.id, symbol.id)
                             elif key == "extend_interface":
                                 graph.connect_entities("EXTENDS", entity.id, symbol.id)
-                    for _, child in entity.children.items():
-                        child.resolved_symbol(lambda key, symbol: analyzers[file_path.suffix].resolve_symbol(self.files, lsps[file_path.suffix], file_path, key, symbol))
-                        for key, symbols in child.resolved_symbols.items():
-                            for symbol in symbols:
-                                if key == "call":
-                                    graph.connect_entities("CALLS", child.id, symbol.id)
-                                elif key == "return_type":
-                                    graph.connect_entities("RETURNS", child.id, symbol.id)
-                                elif key == "parameters":
-                                    graph.connect_entities("PARAMETERS", child.id, symbol.id)
+                            elif key == "call":
+                                graph.connect_entities("CALLS", entity.id, symbol.id)
+                            elif key == "return_type":
+                                graph.connect_entities("RETURNS", entity.id, symbol.id)
+                            elif key == "parameters":
+                                graph.connect_entities("PARAMETERS", entity.id, symbol.id)
 
     def analyze_file(self, file_path: Path, path: Path, graph: Graph) -> None:
         ext = file_path.suffix