code-prune 1.1.0__tar.gz → 1.2.0__tar.gz

{code_prune-1.1.0 → code_prune-1.2.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.2.0 - 2026-11-15
+
+### Added
+
+- `--search-path`: files and/or directories (separated by `;`) searched
+  textually for each `unused-symbol` candidate. Symbols found there are no
+  longer reported. Classes and functions/methods are both matched with a
+  whole-word regex; a method additionally requires its enclosing class's name
+  to be found in the same file. The symbol's own file is ignored and
+  `.codepruneignore` rules apply.
+- `--search-ext`: extensions of the files searched in `--search-path`
+  (default: every text file). Requires `--search-path`.
+
 ## 1.1.0 - 2026-11-05
 
 ### Added

{code_prune-1.1.0 → code_prune-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-prune
-Version: 1.1.0
+Version: 1.2.0
 Summary: Find unreachable, unused, and obsolete code before it becomes technical debt.
 License: MIT License
          
@@ -56,7 +56,7 @@ Description-Content-Type: text/markdown
 
 # code-prune
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/rcw3bb/code-prune/blob/main/LICENSE) [![Version](https://img.shields.io/badge/Version-1.1.0-green.svg)](https://github.com/rcw3bb/code-prune/blob/main/CHANGELOG.md) [![Python](https://img.shields.io/badge/Python-3.14%2B-blue)](https://www.python.org/) [![PyPI](https://img.shields.io/badge/PyPI-code--prune-orange)](https://pypi.org/project/code-prune/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/rcw3bb/code-prune/blob/main/LICENSE) [![Version](https://img.shields.io/badge/Version-1.2.0-green.svg)](https://github.com/rcw3bb/code-prune/blob/main/CHANGELOG.md) [![Python](https://img.shields.io/badge/Python-3.14%2B-blue)](https://www.python.org/) [![PyPI](https://img.shields.io/badge/PyPI-code--prune-orange)](https://pypi.org/project/code-prune/)
 
 
 A CLI tool that scans a codebase for unreachable, unused, and obsolete code,
@@ -120,11 +120,14 @@ Common options:
 | `--workers`       | Number of parallel worker threads used to scan files.                      |
 | `--db`            | Path to the SQLite scratch database used during a scan run.                |
 | `--target-list`   | Treat `path` as a file listing target paths, one per line.                 |
+| `--search-path`   | Files and/or directories (separated by `;`) searched textually for each `unused-symbol` candidate; a symbol found there is not reported. Classes and functions/methods are both matched by a whole-word regex; a method additionally requires its enclosing class's name to appear in the same file. The symbol's own file is skipped and `.codepruneignore` rules apply. |
+| `--search-ext`    | Comma-separated extensions of the files searched in `--search-path` (e.g. `xml,json`). Omit to search every text file. Requires `--search-path`. |
 
 Example:
 
 ```powershell
 code-prune src --categories unreachable,unused-import,todo-marker --format all
+code-prune src --categories unused-symbol --search-path "templates;../other-repo" --search-ext xml,json,py
 ```
 
 ### Reports

{code_prune-1.1.0 → code_prune-1.2.0}/README.md

@@ -1,6 +1,6 @@
 # code-prune
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/rcw3bb/code-prune/blob/main/LICENSE) [![Version](https://img.shields.io/badge/Version-1.1.0-green.svg)](https://github.com/rcw3bb/code-prune/blob/main/CHANGELOG.md) [![Python](https://img.shields.io/badge/Python-3.14%2B-blue)](https://www.python.org/) [![PyPI](https://img.shields.io/badge/PyPI-code--prune-orange)](https://pypi.org/project/code-prune/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/rcw3bb/code-prune/blob/main/LICENSE) [![Version](https://img.shields.io/badge/Version-1.2.0-green.svg)](https://github.com/rcw3bb/code-prune/blob/main/CHANGELOG.md) [![Python](https://img.shields.io/badge/Python-3.14%2B-blue)](https://www.python.org/) [![PyPI](https://img.shields.io/badge/PyPI-code--prune-orange)](https://pypi.org/project/code-prune/)
 
 
 A CLI tool that scans a codebase for unreachable, unused, and obsolete code,
@@ -64,11 +64,14 @@ Common options:
 | `--workers`       | Number of parallel worker threads used to scan files.                      |
 | `--db`            | Path to the SQLite scratch database used during a scan run.                |
 | `--target-list`   | Treat `path` as a file listing target paths, one per line.                 |
+| `--search-path`   | Files and/or directories (separated by `;`) searched textually for each `unused-symbol` candidate; a symbol found there is not reported. Classes and functions/methods are both matched by a whole-word regex; a method additionally requires its enclosing class's name to appear in the same file. The symbol's own file is skipped and `.codepruneignore` rules apply. |
+| `--search-ext`    | Comma-separated extensions of the files searched in `--search-path` (e.g. `xml,json`). Omit to search every text file. Requires `--search-path`. |
 
 Example:
 
 ```powershell
 code-prune src --categories unreachable,unused-import,todo-marker --format all
+code-prune src --categories unused-symbol --search-path "templates;../other-repo" --search-ext xml,json,py
 ```
 
 ### Reports

{code_prune-1.1.0 → code_prune-1.2.0}/code_prune/__init__.py

@@ -10,7 +10,7 @@ Since: 1.0.0
 from env_dir_bootstrap import EnvDirBootstrap
 
 __app_name__ = "code-prune"
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 _bootstrapper = EnvDirBootstrap(
     env_var="CODE_PRUNE_CONFIG_DIR",

{code_prune-1.1.0 → code_prune-1.2.0}/code_prune/cli.py

@@ -44,6 +44,7 @@ from .scanner import (
     load_name_ignore_patterns,
     scan_file,
 )
+from .searcher import SymbolSearcher
 from .store import SessionStore
 
 _VALID_FORMATS = ("json", "html", "all")
@@ -288,11 +289,14 @@ def discover_files(
     path: Path,
     extensions: list[str],
     ignore: IgnoreFile | _CombinedIgnore | None = None,
+    restrict_to_supported: bool = True,
 ) -> list[Path]:
-    """Discover supported source files under *path*.
+    """Discover source files under *path*.
 
-    Only files with an extension in :data:`SUPPORTED_EXTENSIONS` are returned;
-    when *extensions* is given it narrows that set further. Both files and
+    By default only files with an extension in :data:`SUPPORTED_EXTENSIONS`
+    are returned and *extensions* narrows that set further. With
+    ``restrict_to_supported=False`` (used for search paths) *extensions* is
+    taken as-is and an empty list accepts every file. Both files and
     directories are accepted. When *ignore* is given, matching files are
     skipped and matching directories are pruned from the walk entirely.
 
@@ -307,11 +311,16 @@ def discover_files(
     else:
         return []
 
-    allowed = (
-        SUPPORTED_EXTENSIONS.intersection(extensions)
-        if extensions
-        else SUPPORTED_EXTENSIONS
-    )
+    if restrict_to_supported:
+        allowed = (
+            SUPPORTED_EXTENSIONS.intersection(extensions)
+            if extensions
+            else SUPPORTED_EXTENSIONS
+        )
+    elif not extensions:
+        return candidates
+    else:
+        allowed = frozenset(extensions)
     return [f for f in candidates if f.suffix.lower() in allowed]
 
 
@@ -432,6 +441,25 @@ def _run_concurrent_scan(
         "path list. Blank lines and lines starting with '#' are skipped."
     ),
 )
+@click.option(
+    "--search-path",
+    "search_path",
+    default="",
+    help=(
+        "Semicolon-separated files and/or directories searched textually for "
+        "each unused-symbol candidate. A symbol found there is not reported. "
+        "Classes are matched by name; functions/methods by a whole-word regex."
+    ),
+)
+@click.option(
+    "--search-ext",
+    "search_ext",
+    default="",
+    help=(
+        "Comma-separated extensions of the files to search in --search-path "
+        "(e.g. xml,json,py). Omit to search every text file."
+    ),
+)
 def main(  # pylint: disable=too-many-arguments,too-many-positional-arguments,too-many-locals
     path: str,
     ext: str,
@@ -442,6 +470,8 @@ def main(  # pylint: disable=too-many-arguments,too-many-positional-arguments,to
     db_path: Path,
     categories: str,
     target_list: bool,
+    search_path: str,
+    search_ext: str,
 ) -> None:
     """Scan source files for unreachable, unused, and obsolete code.
 
@@ -458,6 +488,10 @@ def main(  # pylint: disable=too-many-arguments,too-many-positional-arguments,to
             f"[yellow]Ignoring unsupported extension(s): {', '.join(unsupported)}[/yellow]"
         )
     selected_categories = _parse_categories(categories)
+    search_paths = _parse_paths(search_path)
+    search_extensions = _parse_extensions(search_ext)
+    if search_extensions and not search_paths:
+        raise click.UsageError("--search-ext requires --search-path.")
     paths = _parse_paths(path)
     if target_list:
         if len(paths) != 1 or not paths[0].is_file():
@@ -474,7 +508,10 @@ def main(  # pylint: disable=too-many-arguments,too-many-positional-arguments,to
 
     _console.print(f"[bold]Scanning[/bold] {len(files)} file(s)\u2026")
 
-    findings, interrupted = _scan_project(files, db_path, workers, selected_categories)
+    searcher = _build_searcher(search_paths, search_extensions)
+    findings, interrupted = _scan_project(
+        files, db_path, workers, selected_categories, searcher
+    )
 
     if interrupted:
         raise SystemExit(1)
@@ -498,7 +535,9 @@ def main(  # pylint: disable=too-many-arguments,too-many-positional-arguments,to
     )
 
 
-def _discover_all_files(paths: list[Path], extensions: list[str]) -> list[Path]:
+def _discover_all_files(
+    paths: list[Path], extensions: list[str], restrict_to_supported: bool = True
+) -> list[Path]:
     """Discover the de-duplicated set of files to scan across *paths*.
 
     Author: Ron Webb
@@ -509,15 +548,36 @@ def _discover_all_files(paths: list[Path], extensions: list[str]) -> list[Path]:
     with _console.status("[bold cyan]Discovering files\u2026", spinner="dots"):
         for target_path in paths:
             ignore = _build_combined_ignore(target_path)
-            for found_file in discover_files(target_path, extensions, ignore):
+            for found_file in discover_files(
+                target_path, extensions, ignore, restrict_to_supported
+            ):
                 if found_file not in seen:
                     seen.add(found_file)
                     files.append(found_file)
     return files
 
 
+def _build_searcher(
+    search_paths: list[Path], search_extensions: list[str]
+) -> SymbolSearcher | None:
+    """Build a :class:`SymbolSearcher` over *search_paths*, or ``None`` when unset.
+
+    Author: Ron Webb
+    Since: 1.2.0
+    """
+    if not search_paths:
+        return None
+    search_files = _discover_all_files(search_paths, search_extensions, False)
+    _logger.info("Searching %s file(s) for unused-symbol references", len(search_files))
+    return SymbolSearcher(search_files)
+
+
 def _scan_project(
-    files: list[Path], db_path: Path, workers: int, categories: set[str]
+    files: list[Path],
+    db_path: Path,
+    workers: int,
+    categories: set[str],
+    searcher: SymbolSearcher | None = None,
 ) -> tuple[list[dict[str, object]], bool]:
     """Run the full scan pipeline and return ``(findings, interrupted)``.
 
@@ -534,7 +594,7 @@ def _scan_project(
         if CATEGORY_UNUSED_SYMBOL in categories:
             name_ignore_patterns = load_name_ignore_patterns(Path(SYMBOL_IGNORE_PATH))
             findings.extend(
-                store.compute_unused_symbols(session_id, name_ignore_patterns)
+                store.compute_unused_symbols(session_id, name_ignore_patterns, searcher)
             )
     except KeyboardInterrupt:
         interrupted = True

{code_prune-1.1.0 → code_prune-1.2.0}/code_prune/scanner.py

@@ -32,6 +32,8 @@ CATEGORY_UNREACHABLE = "unreachable"
 CATEGORY_UNUSED_IMPORT = "unused-import"
 CATEGORY_UNUSED_LOCAL = "unused-local"
 CATEGORY_UNUSED_SYMBOL = "unused-symbol"
+SYMBOL_KIND_CLASS = "class"
+SYMBOL_KIND_FUNCTION = "function"
 CATEGORY_OBSOLETE = "obsolete"
 CATEGORY_TODO_MARKER = "todo-marker"
 CATEGORY_COMMENTED_OUT = "commented-out"
@@ -242,6 +244,10 @@ class Finding:
 class Definition:
     """A function/class/method definition discovered in one file.
 
+    ``enclosing_class`` is the name of the class a method is directly
+    declared in (``None`` for classes and free functions); it lets search-path
+    matching require both the class and method names to appear together.
+
     Author: Ron Webb
     Since: 1.0.0
     """
@@ -251,6 +257,7 @@ class Definition:
     file_path: Path
     line: int
     column: int
+    enclosing_class: str | None = None
 
 
 @dataclass
@@ -513,7 +520,7 @@ def _collect_bindings(
     function_types = FUNCTION_NODE_TYPES.get(language, frozenset())
     class_types = CLASS_NODE_TYPES.get(language, frozenset())
 
-    def walk(node: Node, inside_function: bool) -> None:
+    def walk(node: Node, inside_function: bool, enclosing_class: str | None) -> None:
         if node.type in import_types:
             for name_node in _import_bound_name_nodes(node, language):
                 bindings.import_bindings.append(
@@ -528,25 +535,34 @@ def _collect_bindings(
                     (name_node, _decode(source_bytes, name_node))
                 )
                 bindings.excluded_positions.add(name_node.start_byte)
+        child_enclosing_class = enclosing_class
         if node.type in function_types or node.type in class_types:
             name_node = node.child_by_field_name("name")
+            is_class = node.type in class_types
+            kind = SYMBOL_KIND_CLASS if is_class else SYMBOL_KIND_FUNCTION
             if name_node is not None:
-                kind = "class" if node.type in class_types else "function"
+                decoded_name = _decode(source_bytes, name_node)
                 bindings.definitions.append(
                     Definition(
-                        name=_decode(source_bytes, name_node),
+                        name=decoded_name,
                         kind=kind,
                         file_path=file_path,
                         line=name_node.start_point[0] + 1,
                         column=name_node.start_point[1],
+                        enclosing_class=None if is_class else enclosing_class,
                     )
                 )
                 bindings.excluded_positions.add(name_node.start_byte)
+            # A method's body is local scope: nested definitions are not
+            # themselves direct members of the enclosing class.
+            child_enclosing_class = (
+                decoded_name if is_class and name_node is not None else None
+            )
             inside_function = inside_function or node.type in function_types
         for child in node.children:
-            walk(child, inside_function)
+            walk(child, inside_function, child_enclosing_class)
 
-    walk(tree.root_node, False)
+    walk(tree.root_node, False, None)
     return bindings
 
 

code_prune-1.2.0/code_prune/searcher.py

@@ -0,0 +1,145 @@
+"""Textual search of extra paths for symbols reported as unused.
+
+Symbols that are only referenced from files outside the scanned project
+(templates, configuration, other code bases) would otherwise be reported as
+unused. :class:`SymbolSearcher` checks such files purely textually, without
+parsing them. Both class and function/method names are matched with the same
+whole-word regular expression; a method defined inside a class is only
+considered referenced when its own name *and* its enclosing class's name are
+both found in the same search file.
+
+Author: Ron Webb
+Since: 1.2.0
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .scanner import SYMBOL_KIND_FUNCTION
+
+#: ``(name, kind, defining_file, enclosing_class)``. ``enclosing_class`` is
+#: ``None`` for classes and free functions.
+Candidate = tuple[str, str, str, str | None]
+
+
+def _build_pattern(name: str) -> re.Pattern[str]:
+    """Return a whole-word regex for *name* that also treats ``$`` as a word character.
+
+    Author: Ron Webb
+    Since: 1.2.0
+    """
+    return re.compile(rf"(?<![\w$]){re.escape(name)}(?![\w$])")
+
+
+def _read_text(file_path: Path) -> str | None:
+    """Return the text of *file_path*, or ``None`` for unreadable/binary files.
+
+    Author: Ron Webb
+    Since: 1.2.0
+    """
+    try:
+        data = file_path.read_bytes()
+    except OSError:
+        return None
+    if b"\x00" in data:
+        return None
+    return data.decode("utf-8", errors="replace")
+
+
+class SymbolSearcher:
+    """Find which symbols are textually referenced in a set of search files.
+
+    Author: Ron Webb
+    Since: 1.2.0
+    """
+
+    def __init__(self, search_files: list[Path]) -> None:
+        """Store the files to search.
+
+        Author: Ron Webb
+        Since: 1.2.0
+        """
+        self._search_files = search_files
+
+    def find_referenced(self, candidates: list[Candidate]) -> set[Candidate]:
+        """Return the subset of *candidates* found in the search files.
+
+        The candidate's own defining file is never counted as a reference.
+        Every search file is read once and the search stops as soon as every
+        candidate has been resolved.
+
+        Author: Ron Webb
+        Since: 1.2.0
+        """
+        pending = set(candidates)
+        found: set[Candidate] = set()
+        patterns: dict[str, re.Pattern[str]] = {}
+        for search_file in self._search_files:
+            if not pending:
+                break
+            text = _read_text(search_file)
+            if text is None:
+                continue
+            resolved = _resolve(search_file)
+            hits = self._matches_in_text(text, resolved, pending, patterns)
+            found.update(hits)
+            pending.difference_update(hits)
+        return found
+
+    @staticmethod
+    def _matches_in_text(
+        text: str,
+        resolved_file: str,
+        pending: set[Candidate],
+        patterns: dict[str, re.Pattern[str]],
+    ) -> set[Candidate]:
+        """Return the *pending* candidates referenced in *text*.
+
+        A plain class or free function matches once its own name is found. A
+        method (``enclosing_class`` set) additionally requires its enclosing
+        class's name to be found in the same *text*.
+
+        Author: Ron Webb
+        Since: 1.2.0
+        """
+        hits: set[Candidate] = set()
+        for candidate in pending:
+            name, kind, defining_file, enclosing_class = candidate
+            if _resolve(Path(defining_file)) == resolved_file:
+                continue
+            if not _name_matches(text, name, patterns):
+                continue
+            if (
+                kind == SYMBOL_KIND_FUNCTION
+                and enclosing_class
+                and not _name_matches(text, enclosing_class, patterns)
+            ):
+                continue
+            hits.add(candidate)
+        return hits
+
+
+def _name_matches(text: str, name: str, patterns: dict[str, re.Pattern[str]]) -> bool:
+    """Return whether *name* occurs as a whole word in *text*.
+
+    Author: Ron Webb
+    Since: 1.2.0
+    """
+    if name not in text:
+        return False
+    pattern = patterns.setdefault(name, _build_pattern(name))
+    return pattern.search(text) is not None
+
+
+def _resolve(path: Path) -> str:
+    """Return a normalised string form of *path* for own-file comparison.
+
+    Author: Ron Webb
+    Since: 1.2.0
+    """
+    try:
+        return str(path.resolve())
+    except OSError:
+        return str(path.absolute())

{code_prune-1.1.0 → code_prune-1.2.0}/code_prune/store.py

@@ -21,6 +21,7 @@ import threading
 from pathlib import Path
 
 from .scanner import CATEGORY_UNUSED_SYMBOL, Definition, Finding
+from .searcher import SymbolSearcher
 
 _CREATE_FINDINGS_TABLE = (
     "CREATE TABLE IF NOT EXISTS findings ("
@@ -35,14 +36,16 @@ _CREATE_FINDINGS_TABLE = (
 )
 _CREATE_DEFINITIONS_TABLE = (
     "CREATE TABLE IF NOT EXISTS definitions ("
-    "    session_id TEXT NOT NULL,"
-    "    file_path  TEXT NOT NULL,"
-    "    line       INTEGER NOT NULL,"
-    "    col        INTEGER NOT NULL,"
-    "    name       TEXT NOT NULL,"
-    "    kind       TEXT NOT NULL"
+    "    session_id      TEXT NOT NULL,"
+    "    file_path       TEXT NOT NULL,"
+    "    line            INTEGER NOT NULL,"
+    "    col             INTEGER NOT NULL,"
+    "    name            TEXT NOT NULL,"
+    "    kind            TEXT NOT NULL,"
+    "    enclosing_class TEXT"
     ")"
 )
+_ADD_ENCLOSING_CLASS_COLUMN = "ALTER TABLE definitions ADD COLUMN enclosing_class TEXT"
 _CREATE_IDENTIFIERS_TABLE = (
     "CREATE TABLE IF NOT EXISTS identifiers ("
     "    session_id TEXT NOT NULL,"
@@ -65,8 +68,9 @@ _INSERT_FINDING = (
     " VALUES (?, ?, ?, ?, ?, ?, ?)"
 )
 _INSERT_DEFINITION = (
-    "INSERT INTO definitions (session_id, file_path, line, col, name, kind)"
-    " VALUES (?, ?, ?, ?, ?, ?)"
+    "INSERT INTO definitions"
+    " (session_id, file_path, line, col, name, kind, enclosing_class)"
+    " VALUES (?, ?, ?, ?, ?, ?, ?)"
 )
 _INSERT_IDENTIFIER = "INSERT INTO identifiers (session_id, name) VALUES (?, ?)"
 
@@ -75,7 +79,7 @@ _SELECT_FINDINGS = (
     " WHERE session_id = ? ORDER BY file_path ASC, line ASC, col ASC"
 )
 _SELECT_UNUSED_DEFINITIONS = (
-    "SELECT d.file_path, d.line, d.col, d.name, d.kind"
+    "SELECT d.file_path, d.line, d.col, d.name, d.kind, d.enclosing_class"
     " FROM definitions d"
     " WHERE d.session_id = ?"
     " AND NOT EXISTS ("
@@ -121,11 +125,27 @@ class SessionStore:
             self._conn.execute(_CREATE_FINDINGS_TABLE)
             self._conn.execute(_CREATE_DEFINITIONS_TABLE)
             self._conn.execute(_CREATE_IDENTIFIERS_TABLE)
+            self._migrate_definitions_table()
             self._conn.execute(_CREATE_FINDINGS_INDEX)
             self._conn.execute(_CREATE_DEFINITIONS_INDEX)
             self._conn.execute(_CREATE_IDENTIFIERS_INDEX)
             self._conn.commit()
 
+    def _migrate_definitions_table(self) -> None:
+        """Add the ``enclosing_class`` column to a pre-1.2.0 ``definitions`` table.
+
+        The scratch database file is reused across runs, so a table created
+        by an older version may be missing this column.
+
+        Author: Ron Webb
+        Since: 1.2.0
+        """
+        columns = {
+            row[1] for row in self._conn.execute("PRAGMA table_info(definitions)")
+        }
+        if "enclosing_class" not in columns:
+            self._conn.execute(_ADD_ENCLOSING_CLASS_COLUMN)
+
     def insert_findings(self, session_id: str, findings: list[Finding]) -> None:
         """Persist *findings* for *session_id* in the database.
 
@@ -157,7 +177,15 @@ class SessionStore:
         Since: 1.0.0
         """
         rows = [
-            (session_id, str(d.file_path), d.line, d.column, d.name, d.kind)
+            (
+                session_id,
+                str(d.file_path),
+                d.line,
+                d.column,
+                d.name,
+                d.kind,
+                d.enclosing_class,
+            )
             for d in definitions
         ]
         with self._lock:
@@ -196,14 +224,18 @@ class SessionStore:
         ]
 
     def compute_unused_symbols(
-        self, session_id: str, ignore_patterns: list[re.Pattern[str]]
+        self,
+        session_id: str,
+        ignore_patterns: list[re.Pattern[str]],
+        searcher: SymbolSearcher | None = None,
     ) -> list[dict[str, object]]:
         """Return a finding for every definition never referenced elsewhere.
 
         A definition is "unused" when its name never appears in the
         project-wide ``identifiers`` table collected for *session_id*. Names
         matching any of *ignore_patterns* (e.g. dunder methods, ``main``,
-        test hooks) are suppressed.
+        test hooks) are suppressed. When *searcher* is given, definitions that
+        it finds textually referenced in the search paths are suppressed too.
 
         Author: Ron Webb
         Since: 1.0.0
@@ -212,9 +244,20 @@ class SessionStore:
             rows = self._conn.execute(
                 _SELECT_UNUSED_DEFINITIONS, (session_id,)
             ).fetchall()
+        rows = [
+            row for row in rows if not any(p.search(row[3]) for p in ignore_patterns)
+        ]
+        referenced: set[tuple[str, str, str, str | None]] = set()
+        if searcher is not None:
+            referenced = searcher.find_referenced(
+                [
+                    (name, kind, file_path, enclosing_class)
+                    for file_path, _, _, name, kind, enclosing_class in rows
+                ]
+            )
         results: list[dict[str, object]] = []
-        for file_path, line, col, name, kind in rows:
-            if any(p.search(name) for p in ignore_patterns):
+        for file_path, line, col, name, kind, enclosing_class in rows:
+            if (name, kind, file_path, enclosing_class) in referenced:
                 continue
             results.append(
                 {

{code_prune-1.1.0 → code_prune-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "code-prune"
-version = "1.1.0"
+version = "1.2.0"
 description = "Find unreachable, unused, and obsolete code before it becomes technical debt."
 authors = [
     {name = "Ron Webb"}