Function find_dead_code

code_review_graph/refactor.py:240–579

Find functions/classes with no callers, no test refs, no importers, and no references. Entry points (functions matching framework decorators or conventional name patterns like ``main``, ``test_*``, ``handle_*``) are excluded. .. note:: **Caveats — dynamic dispatch patterns.**

(
    store: GraphStore,
    kind: Optional[str] = None,
    file_pattern: Optional[str] = None,
    root: Optional[Union[str, Path]] = None,
)

def find_dead_code(
    store: GraphStore,
    kind: Optional[str] = None,
    file_pattern: Optional[str] = None,
    root: Optional[Union[str, Path]] = None,
) -> list[dict[str, Any]]:
    """Find functions/classes with no callers, no test refs, no importers, and no references.

    Entry points (functions matching framework decorators or conventional name
    patterns like ``main``, ``test_*``, ``handle_*``) are excluded.

    .. note::

        **Caveats — dynamic dispatch patterns.**  Static analysis cannot track
        all runtime-determined call patterns.  Functions registered via fully
        dynamic keys (``map[computedKey()] = fn``), ``Reflect.apply``, or
        runtime ``require()`` may still appear as dead code.  Treat results as
        hints, especially for TypeScript projects that use map-based dispatch,
        plugin registries, or dynamic requires.

    Args:
        store: The GraphStore instance.
        kind: Optional filter (e.g. ``"Function"`` or ``"Class"``).
        file_pattern: Optional file-path substring filter.
        root: Optional repo root path for computing ``relative_path``.

    Returns:
        List of dead-code dicts with name, qualified_name, kind, file_path,
        relative_path, line, and language fields.
    """
    # Query candidate nodes.
    candidates = store.get_nodes_by_kind(
        kinds=[kind] if kind else ["Function", "Class"],
        file_pattern=file_pattern,
    )

    # Build set of class names referenced in function type annotations.
    type_ref_names = _collect_type_referenced_names(store)

    # Build class hierarchy: class_qualified_name -> [bare_base_names]
    class_bases: dict[str, list[str]] = {}
    conn = store._conn
    for row in conn.execute(
        "SELECT source_qualified, target_qualified FROM edges WHERE kind = 'INHERITS'"
    ).fetchall():
        base = row[1].rsplit("::", 1)[-1] if "::" in row[1] else row[1]
        class_bases.setdefault(row[0], []).append(base)

    # Build import graph: file_path -> set of file_paths it imports from.
    # Used to filter bare-name caller matches to plausible callers.
    importer_files: dict[str, set[str]] = {}
    for row in conn.execute(
        "SELECT file_path, target_qualified FROM edges WHERE kind = 'IMPORTS_FROM'"
    ).fetchall():
        importer_files.setdefault(row[0], set()).add(row[1])

    # Build set of globally unique names (only one non-test node with that name).
    # For unique names, any bare-name CALLS edge is reliable — no ambiguity.