fix bug

Author: AviAvni

api/analyzers/analyzer.py

@@ -63,7 +63,7 @@ def get_entity_docstring(self, node: Node) -> Optional[str]:
         pass
 
     @abstractmethod
-    def get_top_level_entity_types(self) -> list[str]:
+    def get_entity_types(self) -> list[str]:
         """
         Get the top level entity types for the language.
 
@@ -84,17 +84,6 @@ def add_symbols(self, entity: Entity) -> None:
 
         pass
 
-    @abstractmethod
-    def add_children(self, entity: Entity) -> None:
-        """
-        Add children to the entity.
-
-        Args:
-            entity (Entity): The entity to add children to.
-        """
-
-        pass
-
     @abstractmethod
     def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, path: Path, key: str, symbol: Node) -> Entity:
         """

api/analyzers/java/analyzer.py

@@ -47,24 +47,8 @@ def find_calls(self, method: Entity):
             for caller in captures['reference.call']:
                 method.add_symbol("call", caller)
 
-    def find_methods(self, type: Entity):
-        query = self.language.query("[(method_declaration) (constructor_declaration)] @definition.method")
-        captures = query.captures(type.node)
-        if 'definition.method' in captures:
-            for method_dec in captures['definition.method']:
-                method = Entity(method_dec)
-                query = self.language.query("(formal_parameters (formal_parameter type: (_) @parameter))")
-                captures = query.captures(method_dec)
-                if 'parameter' in captures:
-                    for parameter in captures['parameter']:
-                        method.add_symbol("parameters", parameter)
-                if method_dec.type == 'method_declaration':
-                    method.add_symbol("return_type", method_dec.child_by_field_name('type'))
-                type.add_child(method)
-                self.find_calls(method)
-
-    def get_top_level_entity_types(self) -> list[str]:
-        return ['class_declaration', 'interface_declaration', 'enum_declaration']
+    def get_entity_types(self) -> list[str]:
+        return ['class_declaration', 'interface_declaration', 'enum_declaration', 'method_declaration', 'constructor_declaration']
 
     def add_symbols(self, entity: Entity) -> None:
         if entity.node.type == 'class_declaration':
@@ -84,9 +68,8 @@ def add_symbols(self, entity: Entity) -> None:
             if 'type' in extends_captures:
                 for interface in extends_captures['type']:
                     entity.add_symbol("extend_interface", interface)
-
-    def add_children(self, entity: Entity) -> None:
-        self.find_methods(entity)
+        elif entity.node.type in ['method_declaration', 'constructor_declaration']:
+            self.find_calls(entity)
 
     def resolve_type(self, files: dict[Path, File], lsp: SyncLanguageServer, path: Path, node: Node) -> list[Entity]:
         res = []

api/analyzers/python/analyzer.py

@@ -41,25 +41,8 @@ def find_calls(self, method: Entity):
         if 'reference.call' in captures:
             for caller in captures['reference.call']:
                 method.add_symbol("call", caller)
-
-    def find_methods(self, type: Entity):
-        query = self.language.query("(function_definition) @definition.method")
-        captures = query.captures(type.node)
-        if 'definition.method' in captures:
-            for method_dec in captures['definition.method']:
-                method = Entity(method_dec)
-                query = self.language.query("(typed_parameter type: (_) @parameter)")
-                captures = query.captures(method_dec)
-                if 'parameter' in captures:
-                    for parameter in captures['parameter']:
-                        method.add_symbol("parameters", parameter)
-                return_type = method_dec.child_by_field_name('return_type')
-                if return_type:
-                    method.add_symbol("return_type", return_type)
-                type.add_child(method)
-                self.find_calls(method)
 
-    def get_top_level_entity_types(self) -> list[str]:
+    def get_entity_types(self) -> list[str]:
         return ['class_definition', 'function_definition']
 
     def add_symbols(self, entity: Entity) -> None:
@@ -71,9 +54,8 @@ def add_symbols(self, entity: Entity) -> None:
                 if 'base_class' in base_classes_captures:
                     for base_class in base_classes_captures['base_class']:
                         entity.add_symbol("base_class", base_class)
-
-    def add_children(self, entity: Entity) -> None:
-        self.find_methods(entity)
+        elif entity.node.type == 'function_definition':
+            self.find_calls(entity)
 
     def resolve_type(self, files: dict[Path, File], lsp: SyncLanguageServer, path: Path, node: Node) -> list[Entity]:
         res = []
@@ -88,13 +70,8 @@ def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, path:
             method_dec = self.find_parent(resolved_node, ['function_definition', 'class_definition'])
             if not method_dec:
                 continue
-            if method_dec.type == 'class_definition':
-                res.append(file.entities[method_dec])
-            elif method_dec in file.entities:
+            if method_dec in file.entities:
                 res.append(file.entities[method_dec])
-            else:
-                type_dec = self.find_parent(method_dec, ['class_definition'])
-                res.append(file.entities[type_dec].children[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

@@ -39,16 +39,34 @@ def supported_types(self) -> list[str]:
         """
         return list(analyzers.keys())
 
-    def create_hierarchy(self, analyzer: AbstractAnalyzer, file: File):
-        types = analyzer.get_top_level_entity_types()
+    def create_entity_hierarchy(self, entity: Entity, file: File, analyzer: AbstractAnalyzer, graph: Graph):
+        types = analyzer.get_entity_types()
+        stack = list(entity.node.children)
+        while stack:
+            node = stack.pop()
+            if node.type in types:
+                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)
+                entity.add_child(child)
+                graph.connect_entities("DEFINES", entity.id, child.id)
+                self.create_entity_hierarchy(child, file, analyzer, graph)
+            else:
+                stack.extend(node.children)
+
+    def create_hierarchy(self, file: File, analyzer: AbstractAnalyzer, graph: Graph):
+        types = analyzer.get_entity_types()
         stack = [file.tree.root_node]
         while stack:
             node = stack.pop()
             if node.type in types:
                 entity = Entity(node)
+                entity.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(entity)
-                analyzer.add_children(entity)
                 file.add_entity(entity)
+                graph.connect_entities("DEFINES", file.id, entity.id)
+                self.create_entity_hierarchy(entity, file, analyzer, graph)
             else:
                 stack.extend(node.children)
 
@@ -85,15 +103,8 @@ def first_pass(self, path: Path, ignore: list[str], graph: Graph) -> None:
             self.files[file_path] = file
 
             # Walk thought the AST
-            self.create_hierarchy(analyzer, file)
-
             graph.add_file(file)
-            for node, entity in file.entities.items():
-                entity.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, {})
-                graph.connect_entities("DEFINES", file.id, entity.id)
-                for child_node, child_entity in entity.children.items():
-                    child_entity.id = graph.add_entity(analyzer.get_entity_label(child_node), analyzer.get_entity_name(child_node), analyzer.get_entity_docstring(child_node), str(file_path), child_node.start_point.row, child_node.end_point.row, {"src": child_node.text.decode("utf-8")})
-                    graph.connect_entities("DEFINES", entity.id, child_entity.id)
+            self.create_hierarchy(file, analyzer, graph)
 
     def second_pass(self, graph: Graph, path: Path) -> None:
         """