codeanalyzer-python 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

codeanalyzer/semantic_analysis/{codeql/__init__.py → pycg/pycg_exceptions.py}

@@ -14,13 +14,10 @@
 # limitations under the License.
 ################################################################################
 
-"""
-CodeQL package
-"""
 
-from .codeql_analysis import CodeQL
-from .codeql_exceptions import CodeQLExceptions
-from .codeql_loader import CodeQLLoader
-from .codeql_query_runner import CodeQLQueryRunner
+class PyCGExceptions:
+    class PyCGAnalysisError(Exception):
+        """Raised when PyCG fails to analyze a project."""
 
-__all__ = ["CodeQL", "CodeQLQueryRunner", "CodeQLLoader", "CodeQLExceptions"]
+    class PyCGImportError(ImportError):
+        """Raised when the pycg package is not installed."""

codeanalyzer/semantic_analysis/pycg/shard_planner.py

@@ -0,0 +1,401 @@
+################################################################################
+# Copyright IBM Corporation 2025
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+################################################################################
+
+"""Coupling-aware shard planning for PyCG call-graph construction.
+
+Sharding splits a project so PyCG can be run on each part independently; any
+call edge whose caller and callee land in *different* shards becomes a ghost
+node in both, so PyCG never resolves it.  The directory + file-count heuristic
+is blind to coupling and can sever heavily-interacting modules.  This planner
+instead partitions the **module dependency graph derived from the Jedi call
+graph** (already computed at analysis level 1), so the cuts fall on the weakest
+seams.
+
+Pipeline:
+
+1. **Module graph** — project the Jedi ``PyCallEdge`` list (callable→callable)
+   down to a weighted directed graph over *modules*.  ``weight(A, B)`` is the
+   number of Jedi call sites from a callable in module ``A`` to one in ``B``.
+2. **SCC condensation** — modules in an import/call cycle must be co-computed
+   (splitting them breaks both shards), so each strongly-connected component is
+   collapsed into one indivisible unit via Tarjan's algorithm.
+3. **Community detection** — Louvain modularity over the undirected weighted
+   condensation groups tightly-coupled units; each community is a candidate
+   shard.
+4. **Budget enforcement** — communities over the per-shard file budget are
+   re-partitioned (higher Louvain resolution, then a greedy first-fit fallback
+   that guarantees termination); communities under budget are agglomeratively
+   merged by inter-shard weight to recover cut edges and reduce shard count.
+
+The result is a list of shards (each a list of file paths) plus a metrics
+report whose headline figure is ``cut_ratio`` — the fraction of inter-module
+Jedi edge weight severed by the partition.  Lower is better; it is the
+estimated upper bound on PyCG edges lost to sharding.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, Iterator, List, Optional, Set, Tuple
+
+import networkx as nx
+
+from codeanalyzer.schema.py_schema import PyCallable, PyCallEdge, PyClass, PyModule
+
+logger = logging.getLogger(__name__)
+
+
+# ----------------------------------------------------------------------------
+# Symbol-table walking: callable / class signature -> defining file
+# ----------------------------------------------------------------------------
+
+def _walk_callable_sigs(c: PyCallable) -> Iterator[str]:
+    yield c.signature
+    for inner in c.inner_callables.values():
+        yield from _walk_callable_sigs(inner)
+    for inner_cls in c.inner_classes.values():
+        yield from _walk_class_sigs(inner_cls)
+
+
+def _walk_class_sigs(cls: PyClass) -> Iterator[str]:
+    yield cls.signature
+    for method in cls.methods.values():
+        yield from _walk_callable_sigs(method)
+    for inner in cls.inner_classes.values():
+        yield from _walk_class_sigs(inner)
+
+
+def _signature_to_file(symbol_table: Dict[str, PyModule]) -> Dict[str, str]:
+    """Map every callable/class signature in the project to its defining file.
+
+    Built by walking each module's full nesting tree, recording the file that
+    actually defines each callable.  Files are the partition unit because
+    ``PyModule.module_name`` is only the file *stem* (``py_file.stem``), which
+    collides heavily across a real project (every ``__init__.py``, ``models.py``
+    …) — keying the module graph by name would collapse unrelated files into
+    one node and silently drop files from shards.  ``file_path`` is unique.
+    """
+    sig_to_file: Dict[str, str] = {}
+    for module in symbol_table.values():
+        for fn in module.functions.values():
+            for sig in _walk_callable_sigs(fn):
+                sig_to_file[sig] = module.file_path
+        for cls in module.classes.values():
+            for sig in _walk_class_sigs(cls):
+                sig_to_file[sig] = module.file_path
+    return sig_to_file
+
+
+# ----------------------------------------------------------------------------
+# Result type
+# ----------------------------------------------------------------------------
+
+@dataclass
+class ShardPlan:
+    """Output of :func:`plan_shards`.
+
+    ``shards`` is what the PyCG executor consumes: each inner list is the set of
+    project file paths to analyse together as one shard.  ``module_shards`` is
+    the same partition expressed in module names (handy for logging/tests).
+    """
+
+    shards: List[List[str]] = field(default_factory=list)
+    module_shards: List[List[str]] = field(default_factory=list)
+    metrics: Dict[str, float] = field(default_factory=dict)
+
+    def __str__(self) -> str:
+        m = self.metrics
+        return (
+            f"ShardPlan({len(self.shards)} shards, "
+            f"cut_ratio={m.get('cut_ratio', 0):.3f}, "
+            f"max_shard_files={int(m.get('max_shard_files', 0))}, "
+            f"oversized={int(m.get('oversized_shards', 0))})"
+        )
+
+
+# ----------------------------------------------------------------------------
+# Module dependency graph
+# ----------------------------------------------------------------------------
+
+def build_module_graph(
+    symbol_table: Dict[str, PyModule],
+    jedi_edges: List[PyCallEdge],
+) -> nx.DiGraph:
+    """Project Jedi callable→callable edges onto a weighted file DiGraph.
+
+    Nodes are file paths (the unique, collision-free partition unit — see
+    :func:`_signature_to_file`); each carries a ``module_name`` attribute for
+    readable reporting.  Every project file is a node (isolated files
+    included).  Edge weight is the summed Jedi weight of cross-file call sites;
+    intra-file edges and edges touching external/library symbols (no
+    symbol-table entry) are dropped — they cannot influence the partition.
+    """
+    sig_to_file = _signature_to_file(symbol_table)
+
+    g = nx.DiGraph()
+    for module in symbol_table.values():
+        g.add_node(module.file_path, module_name=module.module_name)
+
+    for edge in jedi_edges:
+        src = sig_to_file.get(edge.source)
+        dst = sig_to_file.get(edge.target)
+        if src is None or dst is None or src == dst:
+            continue
+        if g.has_edge(src, dst):
+            g[src][dst]["weight"] += edge.weight
+        else:
+            g.add_edge(src, dst, weight=edge.weight)
+    return g
+
+
+# ----------------------------------------------------------------------------
+# Partitioning
+# ----------------------------------------------------------------------------
+
+def _undirected_weighted(g: nx.DiGraph) -> nx.Graph:
+    """Collapse a directed weighted graph to undirected, summing both directions."""
+    h = nx.Graph()
+    h.add_nodes_from(g.nodes())
+    for u, v, w in g.edges(data="weight", default=1):
+        if h.has_edge(u, v):
+            h[u][v]["weight"] += w
+        else:
+            h.add_edge(u, v, weight=w)
+    return h
+
+
+def _communities(h: nx.Graph, resolution: float, seed: int) -> List[Set[str]]:
+    """Weighted community detection, preferring Louvain with a graceful fallback."""
+    if h.number_of_nodes() == 0:
+        return []
+    if hasattr(nx.community, "louvain_communities"):
+        return [
+            set(c)
+            for c in nx.community.louvain_communities(
+                h, weight="weight", resolution=resolution, seed=seed
+            )
+        ]
+    # networkx < 3.0 (Python 3.9/3.10 floor): greedy modularity has no seed.
+    return [set(c) for c in nx.community.greedy_modularity_communities(h, weight="weight")]
+
+
+def _greedy_bin_pack(
+    units: List[Tuple[frozenset, int]], budget: int
+) -> List[Set[str]]:
+    """First-fit-decreasing pack (unit -> modules, size) into <= budget bins.
+
+    Termination guarantee for the recursive splitter: a community that Louvain
+    refuses to cut still gets divided here.  A single unit larger than the
+    budget (an atomic SCC — a real import cycle) is emitted on its own; that is
+    unavoidable without breaking edges.
+    """
+    bins: List[Tuple[Set[str], int]] = []
+    for members, size in sorted(units, key=lambda u: u[1], reverse=True):
+        placed = False
+        for b in bins:
+            if b[1] + size <= budget:
+                b[0].update(members)
+                bins[bins.index(b)] = (b[0], b[1] + size)
+                placed = True
+                break
+        if not placed:
+            bins.append((set(members), size))
+    return [b[0] for b in bins]
+
+
+def _split_oversized(
+    h: nx.Graph,
+    community: Set[str],
+    unit_size: Dict[str, int],
+    budget: int,
+    seed: int,
+    depth: int = 0,
+) -> List[Set[str]]:
+    """Recursively partition a community whose file count exceeds the budget."""
+    size = sum(unit_size[n] for n in community)
+    if size <= budget or len(community) == 1:
+        # Fits, or is a single atomic SCC unit that cannot be split further.
+        return [community]
+
+    sub = h.subgraph(community)
+    # Escalate resolution so Louvain cuts more aggressively each level.
+    parts = _communities(sub, resolution=2.0 * (depth + 1), seed=seed)
+    parts = [p for p in parts if p]
+
+    if len(parts) <= 1:
+        # Louvain could not divide it (one dense blob) — fall back to bin packing
+        # so the budget is still honoured.
+        units = [(frozenset([n]), unit_size[n]) for n in community]
+        return _greedy_bin_pack(units, budget)
+
+    out: List[Set[str]] = []
+    for p in parts:
+        out.extend(_split_oversized(h, p, unit_size, budget, seed, depth + 1))
+    return out
+
+
+def _merge_small(
+    shards: List[Set[str]],
+    h: nx.Graph,
+    unit_size: Dict[str, int],
+    budget: int,
+) -> List[Set[str]]:
+    """Agglomeratively merge under-budget shards by inter-shard weight.
+
+    Recovers cut edges: merging two shards turns the edges between them back
+    into intra-shard edges.  Greedy — repeatedly merge the heaviest-coupled
+    pair that still fits the budget — which is enough to mop up the small
+    fragments Louvain leaves behind without reintroducing oversized shards.
+    """
+    shards = [set(s) for s in shards]
+    sizes = [sum(unit_size[n] for n in s) for s in shards]
+
+    def pair_weight(a: Set[str], b: Set[str]) -> float:
+        w = 0.0
+        for u in a:
+            for v in h.adj[u]:
+                if v in b:
+                    w += h[u][v]["weight"]
+        return w
+
+    while True:
+        best: Optional[Tuple[int, int]] = None
+        best_w = 0.0
+        for i in range(len(shards)):
+            for j in range(i + 1, len(shards)):
+                if sizes[i] + sizes[j] > budget:
+                    continue
+                w = pair_weight(shards[i], shards[j])
+                if w > best_w:
+                    best_w, best = w, (i, j)
+        if best is None:
+            break
+        i, j = best
+        shards[i] |= shards[j]
+        sizes[i] += sizes[j]
+        del shards[j]
+        del sizes[j]
+
+    # Final consolidation: first-fit pack any shards that still fit together.
+    # Merging zero-coupling shards (e.g. isolated leaf modules) costs no cut
+    # weight and avoids spawning a PyCG process per trivial file.  Packing
+    # never severs an edge, so it is strictly safe; the budget still bounds
+    # per-shard PyCG divergence risk.
+    units = [(frozenset(s), sz) for s, sz in zip(shards, sizes)]
+    return _greedy_bin_pack(units, budget)
+
+
+# ----------------------------------------------------------------------------
+# Public entry point
+# ----------------------------------------------------------------------------
+
+def plan_shards(
+    symbol_table: Dict[str, PyModule],
+    jedi_edges: List[PyCallEdge],
+    budget: int = 100,
+    seed: int = 42,
+    merge_small: bool = True,
+) -> ShardPlan:
+    """Partition a project into coupling-aware PyCG shards.
+
+    Args:
+        symbol_table: The level-1 symbol table (``file_path -> PyModule``).
+        jedi_edges: Jedi-provenance call edges from the level-1 call graph.
+        budget: Maximum number of files per shard.
+        seed: Determinism seed for Louvain.
+        merge_small: Agglomeratively merge under-budget shards to cut shard
+            count and recover edges.
+
+    Returns:
+        A :class:`ShardPlan`.  Shards never silently drop files: every project
+        module appears in exactly one shard (an atomic SCC larger than *budget*
+        yields a single oversized shard, flagged in ``metrics``).
+    """
+    g = build_module_graph(symbol_table, jedi_edges)
+    total_weight = float(sum(w for _, _, w in g.edges(data="weight", default=1)))
+
+    # SCC condensation: each strongly-connected component is one atomic unit.
+    condensation = nx.condensation(g)  # DAG; node attr 'members' = set of modules
+    mapping: Dict[str, int] = condensation.graph["mapping"]  # module -> scc id
+    unit_members: Dict[int, Set[str]] = {
+        scc: set(condensation.nodes[scc]["members"]) for scc in condensation.nodes
+    }
+    unit_size: Dict[int, int] = {scc: len(m) for scc, m in unit_members.items()}
+
+    # Weighted undirected graph over SCC units.
+    hu = nx.Graph()
+    hu.add_nodes_from(condensation.nodes())
+    for u, v, w in g.edges(data="weight", default=1):
+        su, sv = mapping[u], mapping[v]
+        if su == sv:
+            continue
+        if hu.has_edge(su, sv):
+            hu[su][sv]["weight"] += w
+        else:
+            hu.add_edge(su, sv, weight=w)
+
+    # Community detection over units, then budget enforcement.
+    communities = _communities(hu, resolution=1.0, seed=seed)
+    unit_shards: List[Set[str]] = []  # sets of SCC ids
+    for community in communities:
+        unit_shards.extend(
+            _split_oversized(hu, community, unit_size, budget, seed)
+        )
+
+    if merge_small:
+        unit_shards = _merge_small(unit_shards, hu, unit_size, budget)
+
+    # Expand SCC units back to file paths (graph nodes are files).
+    file_shards: List[List[str]] = []
+    for units in unit_shards:
+        files: Set[str] = set()
+        for scc in units:
+            files |= unit_members[scc]
+        if files:
+            file_shards.append(sorted(files))
+
+    # Parallel view in module names (file stems) for human-readable reporting.
+    module_shards = [
+        [g.nodes[f].get("module_name", f) for f in files] for files in file_shards
+    ]
+
+    # Metrics: how much Jedi edge weight does this partition sever?
+    shard_of: Dict[str, int] = {}
+    for idx, files in enumerate(file_shards):
+        for f in files:
+            shard_of[f] = idx
+    cut_weight = 0.0
+    for u, v, w in g.edges(data="weight", default=1):
+        if shard_of.get(u) != shard_of.get(v):
+            cut_weight += w
+
+    sizes = [len(s) for s in module_shards] or [0]
+    metrics = {
+        "modules": float(g.number_of_nodes()),
+        "module_edges": float(g.number_of_edges()),
+        "total_edge_weight": total_weight,
+        "cut_weight": cut_weight,
+        "cut_ratio": (cut_weight / total_weight) if total_weight else 0.0,
+        "num_shards": float(len(module_shards)),
+        "max_shard_files": float(max(sizes)),
+        "oversized_shards": float(sum(1 for s in sizes if s > budget)),
+    }
+
+    plan = ShardPlan(shards=file_shards, module_shards=module_shards, metrics=metrics)
+    logger.info("Shard planner: %s", plan)
+    return plan

codeanalyzer/syntactic_analysis/import_resolver.py

@@ -0,0 +1,67 @@
+"""Static resolution of import spellings against the analyzed module set.
+
+Pure post-pass over a built ``PyApplication``: no filesystem access, no
+sys.path semantics — a spelling resolves iff it names a module that was
+itself analyzed (issue #82). External/library imports stay unresolved by
+design and keep their :PyPackage projection.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Dict, Optional, Union
+
+from codeanalyzer.schema.py_schema import PyApplication
+
+
+def _dotted_candidates(app: PyApplication, project_dir: Union[Path, str]) -> Dict[str, str]:
+    """dotted module path -> file_key, for every analyzed module.
+
+    ``pkg/util.py`` -> ``pkg.util``; ``pkg/__init__.py`` -> ``pkg``.
+    file_keys share project_dir's form (both come from the same CLI arg),
+    so os.path.relpath keeps mixed absolute/relative setups consistent.
+    """
+    mapping: Dict[str, str] = {}
+    for file_key in app.symbol_table:
+        rel = os.path.relpath(file_key, str(project_dir))
+        if rel.startswith(".."):
+            continue
+        parts = Path(rel).with_suffix("").parts
+        if parts and parts[-1] == "__init__":
+            parts = parts[:-1]
+        if parts:
+            mapping[".".join(parts)] = file_key
+    return mapping
+
+
+def _resolve_one(
+    spelling: str, original_name: str, importer_rel_parts: tuple, candidates: Dict[str, str]
+) -> Optional[str]:
+    if spelling.startswith("."):
+        level = len(spelling) - len(spelling.lstrip("."))
+        suffix = spelling.lstrip(".")
+        # level 1 = the importer's own package; each extra dot walks one up.
+        package_parts = importer_rel_parts[:-1]  # drop the filename
+        if level - 1 > len(package_parts):
+            return None
+        base = package_parts[: len(package_parts) - (level - 1)]
+        stems = list(base) + (suffix.split(".") if suffix else [])
+    else:
+        stems = spelling.split(".")
+    dotted = ".".join(stems)
+    with_name = f"{dotted}.{original_name}" if dotted else original_name
+    return candidates.get(with_name) or candidates.get(dotted)
+
+
+def resolve_imports(app: PyApplication, project_dir: Union[Path, str]) -> None:
+    """Stamp ``resolved_module`` on every import of every module, in place."""
+    candidates = _dotted_candidates(app, project_dir)
+    for file_key, module in app.symbol_table.items():
+        rel = os.path.relpath(file_key, str(project_dir))
+        importer_parts = Path(rel).parts
+        for im in module.imports or []:
+            if not im.module:
+                im.resolved_module = None
+                continue
+            original = im.alias or im.name
+            im.resolved_module = _resolve_one(im.module, original, importer_parts, candidates)

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,
@@ -28,7 +30,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 +45,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 +113,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.
 
@@ -203,10 +257,10 @@ 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)
@@ -258,8 +312,7 @@ 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
@@ -380,6 +433,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 +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()
@@ -588,10 +643,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 +660,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)

codeanalyzer/utils/logging.py

@@ -3,8 +3,11 @@ import logging
 from rich.console import Console
 from rich.logging import RichHandler
 
-# Set up base logger with RichHandler
-console = Console()
+# Logs go to stderr so stdout stays clean for piped output (e.g. --emit json | jq).
+# The same console instance is shared with ProgressBar so Rich can coordinate
+# live-display updates with log messages without the two consoles stomping on each
+# other (which causes progress bars to appear twice when a warning interrupts them).
+console = Console(stderr=True)
 handler = RichHandler(console=console, show_time=True, show_level=True, show_path=False)
 
 logger = logging.getLogger("codeanalyzer")