codeanalyzer-python 0.3.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

codeanalyzer/syntactic_analysis/symbol_table_builder.py

@@ -1,5 +1,6 @@
 import ast
 import hashlib
+import os
 import tokenize
 from ast import AST, ClassDef
 from io import StringIO
@@ -13,6 +14,7 @@ from jedi.api.project import Project
 from codeanalyzer.schema.py_schema import (
     PyCallable,
     PyCallableParameter,
+    PyCallArgument,
     PyCallsite,
     PyClass,
     PyClassAttribute,
@@ -21,6 +23,8 @@ from codeanalyzer.schema.py_schema import (
     PyModule,
     PySymbol,
     PyVariableDeclaration,
+    Span,
+    byte_offsets,
 )
 
 
@@ -28,7 +32,11 @@ class SymbolTableBuilder:
     """A class for building a symbol table for a Python project."""
 
     def __init__(self, project_dir: Union[Path, str], virtualenv: Union[Path, str, None]) -> None:
-        self.project_dir = Path(project_dir)
+        # Jedi reports absolute Script paths, so a relative project_dir would
+        # crash every relative_to() fallback below. abspath (not resolve())
+        # keeps symlinks intact, matching Jedi's own absolute()-style
+        # normalization under symlinked roots like macOS /tmp.
+        self.project_dir = Path(os.path.abspath(project_dir))
         if virtualenv is None:
             # If no virtual environment is provided, create a jedi project without an environment.
             self.jedi_project: Project = jedi.Project(path=self.project_dir)
@@ -39,6 +47,16 @@ class SymbolTableBuilder:
                 environment_path=Path(virtualenv) / "bin" / "python",
             )
 
+    def _fallback_signature(self, script_path: Union[Path, str], name: str) -> str:
+        """Path-derived qualified name used when Jedi can't name a definition.
+
+        Strips only the terminal ``.py`` suffix — a bare ``str.replace``
+        would also eat interior ``.py`` substrings and corrupt the module
+        prefix (``odoo/tools/pycompat.py`` → ``odoo.toolscompat``).
+        """
+        relative = Path(script_path).relative_to(self.project_dir)
+        return ".".join(relative.with_suffix("").parts) + f".{name}"
+
     @staticmethod
     def _infer_type(script: Script, line: int, column: int) -> str:
         """Tries to infer the type at a given position using Jedi."""
@@ -97,6 +115,44 @@ class SymbolTableBuilder:
         except Exception:
             return None, False
 
+    @staticmethod
+    def _callee_anchor(node: ast.Call) -> Tuple[int, int]:
+        """Position of the callee *name* for Jedi inference.
+
+        An ``ast.Call``'s own ``lineno``/``col_offset`` is the first
+        character of the whole call expression — for an attribute call
+        ``receiver.method(...)`` that is the receiver token, and Jedi
+        would infer the receiver's type instead of the invoked method
+        (issue #80). Anchor attribute calls inside the attribute name —
+        its last character, so one-character names stay in range; other
+        callee shapes keep the call-expression start.
+        """
+        func_expr = node.func
+        if isinstance(func_expr, ast.Attribute):
+            return func_expr.end_lineno, func_expr.end_col_offset - 1
+        return node.lineno, node.col_offset
+
+    @staticmethod
+    def _infer_call_return_type(script: Script, line: int, column: int) -> Optional[str]:
+        """Inferred type of the call's *result*, not of the callee itself.
+
+        ``Script.infer`` at the callee name yields the function/class
+        being called; executing that definition yields what the call
+        evaluates to — a function's inferred return type, or the
+        instance for a constructor call. Returns ``None`` when Jedi
+        can't tell, so an unknown stays absent instead of masquerading
+        as the callee's own name.
+        """
+        try:
+            definitions = script.infer(line=line, column=column)
+            if definitions:
+                results = definitions[0].execute()
+                if results:
+                    return results[0].name
+        except Exception:
+            pass
+        return None
+
     def build_pymodule_from_file(self, py_file: Path) -> PyModule:
         """Builds a PyModule from a Python file.
 
@@ -123,11 +179,12 @@ class SymbolTableBuilder:
             PyModule.builder()
             .file_path(str(py_file))
             .module_name(py_file.stem)
+            .source(source)
             .comments(self._pycomments(module, source))
             .imports(self._imports(module))
             .variables(self._module_variables(module, script))
-            .classes(self._add_class(module, script))
-            .functions(self._callables(module, script))
+            .types(self._add_class(module, script, source))
+            .functions(self._callables(module, script, source))
             .content_hash(content_hash)
             .last_modified(last_modified)
             .file_size(file_size)
@@ -183,7 +240,7 @@ class SymbolTableBuilder:
 
         return imports
 
-    def _add_class(self, node: AST, script: Script, prefix: str = "") -> Dict[str, PyClass]:
+    def _add_class(self, node: AST, script: Script, source: str, prefix: str = "") -> Dict[str, PyClass]:
         classes: Dict[str, PyClass] = {}
 
         for child in ast.iter_child_nodes(node):
@@ -194,6 +251,14 @@ class SymbolTableBuilder:
             start_line = child.lineno
             end_line = getattr(child, "end_lineno", start_line + len(child.body))
             code = ast.unparse(child).strip()
+            span = Span(
+                start=(child.lineno, child.col_offset),
+                end=(getattr(child, "end_lineno", child.lineno),
+                     getattr(child, "end_col_offset", child.col_offset)),
+                bytes=byte_offsets(source, child.lineno, child.col_offset,
+                                   getattr(child, "end_lineno", child.lineno),
+                                   getattr(child, "end_col_offset", child.col_offset)),
+            )
 
             # Try resolving full signature with Jedi
             if prefix:
@@ -203,26 +268,26 @@ class SymbolTableBuilder:
                     definitions = script.goto(line=start_line, column=child.col_offset)
                     signature = next(
                         (d.full_name for d in definitions if d.type == "class"),
-                        f"{Path(script.path).relative_to(self.project_dir).__str__().replace('/', '.').replace('.py', '')}.{class_name}"
+                        self._fallback_signature(script.path, class_name),
                     )
                 except Exception:
-                    signature = f"{Path(script.path).relative_to(self.project_dir).__str__().replace('/', '.').replace('.py', '')}.{class_name}"
+                    signature = self._fallback_signature(script.path, class_name)
             py_class = (
                 PyClass.builder()
                 .name(class_name)
                 .signature(signature)
+                .span(span)
                 .start_line(start_line)
                 .end_line(end_line)
-                .code(code)
                 .comments(self._pycomments(child, code))
                 .base_classes([
                     ast.unparse(base)
                     for base in child.bases
                     if isinstance(base, ast.expr)
                 ])
-                .methods(self._callables(child, script, prefix=signature))  # Pass class signature as prefix
+                .callables(self._callables(child, script, source, prefix=signature))  # Pass class signature as prefix
                 .attributes(self._class_attributes(child, script))
-                .inner_classes(self._add_class(child, script, prefix=signature))  # Pass class signature as prefix
+                .types(self._add_class(child, script, source, prefix=signature))  # Pass class signature as prefix
                 .build()
             )
 
@@ -231,7 +296,7 @@ class SymbolTableBuilder:
         return classes
 
 
-    def _callables(self, node: AST, script: Script, prefix: str = "") -> Dict[str, PyCallable]:
+    def _callables(self, node: AST, script: Script, source: str, prefix: str = "") -> Dict[str, PyCallable]:
         callables: Dict[str, PyCallable] = {}
 
         for child in ast.iter_child_nodes(node):
@@ -240,6 +305,14 @@ class SymbolTableBuilder:
                 start_line = child.lineno
                 end_line = getattr(child, "end_lineno", start_line + len(child.body))
                 code = ast.unparse(child).strip()
+                span = Span(
+                    start=(child.lineno, child.col_offset),
+                    end=(getattr(child, "end_lineno", child.lineno),
+                         getattr(child, "end_col_offset", child.col_offset)),
+                    bytes=byte_offsets(source, child.lineno, child.col_offset,
+                                       getattr(child, "end_lineno", child.lineno),
+                                       getattr(child, "end_col_offset", child.col_offset)),
+                )
                 decorators = [ast.unparse(d) for d in child.decorator_list]
                 
                 if prefix:
@@ -258,15 +331,14 @@ class SymbolTableBuilder:
                     
                     # If Jedi didn't provide a signature, build one relative to project_dir
                     if not signature:
-                        relative_path = Path(script.path).relative_to(self.project_dir)
-                        signature = f"{str(relative_path).replace('/', '.').replace('.py', '')}.{method_name}"
+                        signature = self._fallback_signature(script.path, method_name)
                 py_callable = (
                     PyCallable.builder()
                     .name(method_name)  # Use the actual method name, not the full signature
                     .path(str(script.path))
                     .signature(signature)  # Use the full signature here
+                    .span(span)
                     .decorators(decorators)
-                    .code(code)
                     .start_line(start_line)
                     .end_line(end_line)
                     .code_start_line(child.body[0].lineno if child.body else start_line)
@@ -280,8 +352,8 @@ class SymbolTableBuilder:
                         if child.returns else self._infer_type(script, child.lineno, child.col_offset)
                     )
                     .comments(self._pycomments(child, code))
-                    .inner_callables(self._callables(child, script, signature))  # Pass current signature as prefix
-                    .inner_classes(self._add_class(child, script, signature))    # Pass current signature as prefix
+                    .callables(self._callables(child, script, source, signature))  # Pass current signature as prefix
+                    .types(self._add_class(child, script, source, signature))    # Pass current signature as prefix
                     .build()
                 )
 
@@ -380,6 +452,7 @@ class SymbolTableBuilder:
                                     script, target.lineno, target.col_offset
                                 )
                             )
+                            .initializer(ast.unparse(stmt.value) if stmt.value else None)
                             .start_line(getattr(target, "lineno", -1))
                             .end_line(getattr(stmt, "end_lineno", stmt.lineno))
                             .build()
@@ -398,6 +471,7 @@ class SymbolTableBuilder:
                                 script, target.lineno, target.col_offset
                             )
                         )
+                        .initializer(ast.unparse(stmt.value) if stmt.value else None)
                         .start_line(getattr(target, "lineno", -1))
                         .end_line(getattr(stmt, "end_lineno", stmt.lineno))
                         .build()
@@ -588,10 +662,11 @@ class SymbolTableBuilder:
             func_expr = node.func
 
             method_name = "<unknown>"
+            anchor_line, anchor_col = self._callee_anchor(node)
             callee_signature, is_constructor = self._infer_callee(
-                script, node.lineno, node.col_offset
+                script, anchor_line, anchor_col
             )
-            return_type = self._infer_type(script, node.lineno, node.col_offset)
+            return_type = self._infer_call_return_type(script, anchor_line, anchor_col)
 
             receiver_expr = None
             receiver_type = None
@@ -604,18 +679,26 @@ class SymbolTableBuilder:
             elif isinstance(func_expr, ast.Name):
                 method_name = func_expr.id
 
-            argument_types = [
-                self._infer_type(script, arg.lineno, arg.col_offset)
-                or type(arg).__name__
+            arguments = [
+                PyCallArgument(
+                    ast_kind=type(arg).__name__,
+                    inferred_type=self._infer_type(script, arg.lineno, arg.col_offset),
+                )
                 for arg in node.args
             ]
 
+            # Legacy field, derived from the structured arguments above rather
+            # than re-inferring: byte-identical to the old
+            # `self._infer_type(...) or type(arg).__name__` per argument.
+            argument_types = [a.inferred_type or a.ast_kind for a in arguments]
+
             call_sites.append(
                 PyCallsite.builder()
                 .method_name(method_name)
                 .receiver_expr(receiver_expr)
                 .receiver_type(receiver_type)
                 .argument_types(argument_types)
+                .arguments(arguments)
                 .return_type(return_type)
                 .callee_signature(callee_signature)
                 .is_constructor_call(is_constructor)