codeboarding 0.15.4__tar.gz → 0.15.5__tar.gz

{codeboarding-0.15.4/codeboarding.egg-info → codeboarding-0.15.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.15.4
+Version: 0.15.5
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.15.4 → codeboarding-0.15.5/codeboarding.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.15.4
+Version: 0.15.5
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.15.4 → codeboarding-0.15.5}/infra/tool_registry/installers.py

@@ -562,23 +562,48 @@ def current_tool(dep: ToolDependency, target_dir: Path | None = None) -> ToolDep
     return replace(dep, source=replace(dep.source, tag=installed)) if installed else dep
 
 
-def archive_tool_is_installed(target_dir: Path, dep: ToolDependency) -> bool:
-    """Whether an archive tool is extracted in full: its launcher at the pinned version, or JDTLS's ``plugins/``."""
+def _archive_tool_is_extracted(target_dir: Path, dep: ToolDependency) -> bool:
+    """Whether an archive tool is extracted in full, at any version: its launcher, or JDTLS's ``plugins/``."""
     launcher = archive_launcher_path(target_dir, dep)
     if launcher is not None:
-        stamp = target_dir / "bin" / dep.archive_subdir / ARCHIVE_VERSION_STAMP
-        return launcher.is_file() and dep.source is not None and _read_stamp(stamp) == dep.source.tag
+        return launcher.is_file()
     return (target_dir / "bin" / dep.archive_subdir / "plugins").is_dir()
 
 
+def archive_tool_is_installed(target_dir: Path, dep: ToolDependency) -> bool:
+    """Whether an archive tool is extracted in full at the pinned version.
+
+    Why the stamp for JDTLS too: with ``plugins/`` alone, an install from before a pin bump counted as current
+    forever, and kept analysing with a server too old to know the project's Java version.
+    """
+    stamp = target_dir / "bin" / dep.archive_subdir / ARCHIVE_VERSION_STAMP
+    return (
+        _archive_tool_is_extracted(target_dir, dep)
+        and dep.source is not None
+        and _read_stamp(stamp) == archive_stamp(dep.source)
+    )
+
+
+def archive_stamp(source: ToolSource) -> str:
+    """What an install of *source* writes into its stamp: the tag, and the build where the pin names one.
+
+    Why the build: JDTLS pins snapshots, and a bump can change only the build.
+    """
+    if isinstance(source, UpstreamToolSource) and source.build:
+        return f"{source.tag}-{source.build}"
+    return source.tag
+
+
 def archive_tool_is_usable(target_dir: Path, dep: ToolDependency) -> bool:
     """Whether a run can start an archive tool as it is on disk.
 
-    kotlin-lsp does not have to be at the latest pin for that, which also keeps a build that a failed update left in
-    place. This asks on every run, whatever its languages, so it must not read main's pin.
+    kotlin-lsp and JDTLS do not have to be at the latest pin for that, which also keeps a build that a failed update
+    left in place. This asks on every run, whatever its languages, so it must not read main's pin.
     """
     if dep.key == "kotlin":
         return _usable_kotlin_lsp_build(target_dir, dep) is not None
+    if archive_launcher_path(target_dir, dep) is None:
+        return _archive_tool_is_extracted(target_dir, dep)
     return archive_tool_is_installed(target_dir, dep)
 
 
@@ -639,7 +664,7 @@ def install_archive_tool(
         shutil.rmtree(extract_dir, ignore_errors=True)
         os.replace(root, extract_dir)
         shutil.rmtree(staging, ignore_errors=True)
-        (extract_dir / ARCHIVE_VERSION_STAMP).write_text(dep.source.tag)
+        (extract_dir / ARCHIVE_VERSION_STAMP).write_text(archive_stamp(dep.source))
         logger.info("%s installed successfully", dep.key)
     except Exception:
         logger.exception("%s installation failed", dep.key)

{codeboarding-0.15.4 → codeboarding-0.15.5}/infra/tool_registry/java.py

@@ -1,5 +1,6 @@
 """Locating a Java 21+ runtime on the host."""
 
+import functools
 import logging
 import os
 import platform
@@ -49,6 +50,14 @@ def detect_java_installations() -> list[Path]:
     if java_home := os.getenv("JAVA_HOME"):
         candidates.append(Path(java_home))
 
+    # GitHub-hosted runners preinstall several JDKs and name each one JAVA_HOME_<major>_<arch>.
+    candidates.extend(Path(value) for name, value in os.environ.items() if re.fullmatch(r"JAVA_HOME_\d+_\w+", name))
+
+    # JDKs Gradle provisioned for a build's toolchain, nested one or two folders deep by vendor.
+    gradle_jdks = Path(os.getenv("GRADLE_USER_HOME") or Path.home() / ".gradle") / "jdks"
+    for pattern in ("*", "*/*", "*/*/Contents/Home"):
+        candidates.extend(gradle_jdks.glob(pattern))
+
     # Platform-specific search paths
     system = platform.system()
 
@@ -94,6 +103,20 @@ def detect_java_installations() -> list[Path]:
     return unique_jdks
 
 
+@functools.cache
+def java_runtimes() -> dict[int, Path]:
+    """One installed JDK per Java major version, for JDTLS to compile each project against the release it targets.
+
+    Why: JDTLS knows only the JDK it runs on, so a project built for a newer release than that has no system library,
+    and every JDK type in it is unresolved.
+    """
+    runtimes: dict[int, Path] = {}
+    for jdk in detect_java_installations():
+        runtimes.setdefault(get_java_version(str(jdk / "bin" / "java")), jdk)
+    runtimes.pop(0, None)
+    return runtimes
+
+
 def find_java_21_or_later() -> Path | None:
     """
     Find a Java 21+ installation.

{codeboarding-0.15.4 → codeboarding-0.15.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeboarding"
-version = "0.15.4"
+version = "0.15.5"
 description = "Interactive Diagrams for Code"
 readme = "PYPI.md"
 license = "MIT"

{codeboarding-0.15.4 → codeboarding-0.15.5}/static_analyzer/engine/adapters/java_adapter.py

@@ -13,13 +13,15 @@ from pathlib import Path
 
 from static_analyzer.config import Language, NodeType
 from static_analyzer.engine.language_adapter import LanguageAdapter
-from static_analyzer.engine.lsp_client import ErrorVerdict
+from static_analyzer.engine.lsp_client import LSP_INTERNAL_ERROR, ErrorVerdict
 from static_analyzer.engine.lsp_constants import (
     CALLABLE_KINDS,
     CLASS_LIKE_KINDS,
 )
 from static_analyzer.engine.utils import total_ram_gb
 from static_analyzer.java_utils import create_jdtls_command, find_java_21_or_later
+from infra.repo_utils.ignore import RepoIgnoreManager
+from infra.tool_registry.java import java_runtimes
 from infra.utils import CODEBOARDING_DIR_NAME, get_config
 
 logger = logging.getLogger(__name__)
@@ -29,6 +31,8 @@ _CLASSPATH_ENTRY = re.compile(
     rb"(<classpathentry\b[^>]*[^/]>)((?:(?!<classpathentry\b).)*?</classpathentry>)", re.DOTALL
 )
 _INCLUSION_FILTER = re.compile(rb'\s+including="[^"]*"')
+# Indexing is one-off and grows with the classpath; a server that cannot search within this is broken.
+_SEARCH_INDEX_TIMEOUT_SECONDS = 1800
 
 # The languages a JVM source root can be named for, in ``src/<source set>/<language>``.
 
@@ -48,6 +52,21 @@ class JavaAdapter(LanguageAdapter):
         """
         return True
 
+    @property
+    def source_names_every_subtype(self) -> bool:
+        """A subclass, an anonymous class body or an enum constant body names its base; a lambda implements only
+        an interface, which is always asked about."""
+        return True
+
+    @property
+    def search_index_timeout(self) -> int | None:
+        """JDTLS indexes the classpath, the JDK included, on its first search.
+
+        Why: on JabRef that took 72-105s, longer than a request may take, so the first round of implementation queries
+        timed out and ended the run.
+        """
+        return _SEARCH_INDEX_TIMEOUT_SECONDS
+
     @property
     def language(self) -> str:
         return "Java"
@@ -273,6 +292,11 @@ class JavaAdapter(LanguageAdapter):
         finally:
             self._restore_import_filters()
 
+    def get_lsp_init_options(self, ignore_manager: RepoIgnoreManager | None = None) -> dict:
+        """The settings at startup too: a Maven import runs before the first settings change, and with
+        ``<release>25</release>`` and no JDK 25 registered by then it reports the release as not found."""
+        return {"settings": self.get_workspace_settings()}
+
     def get_workspace_settings(self) -> dict | None:
         # JDTLS defaults these to "ignore"; raising to "warning" is required
         # for unused-code diagnostics.
@@ -283,7 +307,16 @@ class JavaAdapter(LanguageAdapter):
                     "org.eclipse.jdt.core.compiler.problem.unusedLocal": "warning",
                     "org.eclipse.jdt.core.compiler.problem.unusedPrivateMember": "warning",
                     "org.eclipse.jdt.core.compiler.problem.deadCode": "warning",
-                }
+                },
+                # A project's JDK types resolve only against a JDK at least as new as the release it targets, and
+                # JDTLS knows only the one it runs on unless told of the rest. JabRef targets Java 25.
+                "configuration": {
+                    "runtimes": [
+                        {"name": "JavaSE-1.8" if major == 8 else f"JavaSE-{major}", "path": str(home)}
+                        for major, home in sorted(java_runtimes().items())
+                        if major >= 8
+                    ]
+                },
             }
         }
 
@@ -302,13 +335,17 @@ class JavaAdapter(LanguageAdapter):
         return symbol_kind in (CALLABLE_KINDS | CLASS_LIKE_KINDS | {NodeType.VARIABLE, NodeType.CONSTANT})
 
     def error_verdict(self, error: dict) -> ErrorVerdict:
-        """A crash in JDT's code selection is final for that call site, and its edge is left out with a warning.
+        """An internal error thrown from JDT's compiler or code assist leaves that one call site's edge out.
 
-        Why: asking again crashes the same way, so one site the compiler cannot walk must not cost the whole run.
-        A timeout or a lost server is not this, and still fails it.
+        Why: it is a function of the source alone, so asking again crashes the same way. The first frame past the
+        JDK's own decides. A cancellation or interruption, a JVM error, or a crash in JDT LS's own code still fails.
         """
         data = str(error.get("data", ""))
-        if re.search(r"Caused by: java\.lang\.NullPointerException.*\n\s*at \S*codeassist\.SelectionEngine", data):
+        if error.get("code") == LSP_INTERNAL_ERROR and re.search(
+            r"Caused by: java\.lang\.(?!InterruptedException)\w+Exception\b.*\n(?:\s*at java\.base/.*\n)*"
+            r"\s*at org\.eclipse\.jdt\.internal\.(?:compiler|codeassist)\.",
+            data,
+        ):
             logger.warning(f"JDTLS crashed resolving a call site, leaving its edge out: {data}")
             return ErrorVerdict.DECLINED
         return ErrorVerdict.FAILURE

{codeboarding-0.15.4 → codeboarding-0.15.5}/static_analyzer/engine/edge_builder.py

@@ -233,7 +233,7 @@ def build_edges_via_definitions(
         )
 
     total_impl_resolved = _resolve_implementations(
-        adapter, ctx, resolution.edge_set, resolution.impl_queries_pending, index
+        adapter, ctx, resolution.edge_set, resolution.impl_queries_pending, index, source_files
     )
 
     total_iterated = 0
@@ -446,6 +446,7 @@ def _resolve_implementations(
     edge_set: EdgeMap,
     impl_queries_pending: list[ImplementationQuery],
     index: SymbolIndex,
+    source_files: list[Path],
 ) -> int:
     """Phase 2b: Resolve implementations for polymorphic call targets.
 
@@ -453,23 +454,56 @@ def _resolve_implementations(
     """
     st = ctx.symbol_table
 
+    # A member is only implemented in a type deriving from its owner, so a class no source derives from has nothing
+    # to find. Why: on JabRef 9 in 10 targets were such, and JDTLS took ~0.8s on each to say so, 2.3h in all.
+    # An interface is always asked: a lambda implements one without naming it. Read like the dispatch index, the
+    # known declarations' files too, so a warm start still sees a subclass in an unchanged file.
+    derived: set[str] = set()
+    if adapter.source_names_every_subtype:
+        files = set(source_files) | {
+            sym.file_path for sym in chain(st.symbols.values(), st.known) if adapter.is_class_like(sym.kind)
+        }
+        derived = set(chain.from_iterable(ctx.source_inspector.find_derived_type_names(f) for f in files))
+
     target_pos_to_callers: dict[tuple[str, int, int], list[tuple[str, CallSite]]] = {}
+    underived = 0
     for query in impl_queries_pending:
+        owner = st.symbols.get(parent_qualified_name(query.target_qname))
+        if (
+            adapter.source_names_every_subtype
+            and owner is not None
+            and adapter.is_class_like(owner.kind)
+            and owner.kind != NodeType.INTERFACE
+            # Source names a base without its type parameters; servers name a generic type with them.
+            and owner.name.split("<")[0].strip() not in derived
+        ):
+            underived += 1
+            continue
         tgt_key = (str(query.target_file), query.target_line, query.target_char)
         target_pos_to_callers.setdefault(tgt_key, []).append((query.caller_qname, query.call_site))
 
     targets = list(target_pos_to_callers)
     logger.info(
-        "Phase 2b (implementations): %d unique targets from %d pending queries", len(targets), len(impl_queries_pending)
+        "Phase 2b (implementations): %d unique targets from %d pending queries (%d on a class nothing derives from)",
+        len(targets),
+        len(impl_queries_pending),
+        underived,
     )
 
     total_impl_resolved = 0
     # Why a round at a time here: on a large repository this is the longest phase, and progress is only
     # reported between rounds.
     pbar = ProgressLogger("Phase 2b (impl)", len(targets), unit="target")
-    for start in range(0, len(targets), REQUEST_BATCH_SIZE):
-        batch = targets[start : start + REQUEST_BATCH_SIZE]
-        impl_results = ctx.lsp.send_implementation_batch([(Path(file), line, char) for file, line, char in batch])
+    index_timeout = adapter.search_index_timeout
+    start = 0
+    while start < len(targets):
+        # A server that builds its search index on its first search gets that search alone, with the time indexing
+        # takes; the rounds after it are answered from the index.
+        batch = targets[start : start + (1 if start == 0 and index_timeout else REQUEST_BATCH_SIZE)]
+        impl_results = ctx.lsp.send_implementation_batch(
+            [(Path(file), line, char) for file, line, char in batch], timeout=index_timeout if start == 0 else None
+        )
+        start += len(batch)
         for tgt_key, impls in zip(batch, impl_results):
             callers = target_pos_to_callers[tgt_key]
             for impl_result in impls:

{codeboarding-0.15.4 → codeboarding-0.15.5}/static_analyzer/engine/hierarchy_builder.py

@@ -11,6 +11,7 @@ from static_analyzer.config import NodeType
 from static_analyzer.engine.language_adapter import LanguageAdapter
 from static_analyzer.engine.lsp_client import LSPClient, MethodNotFoundError
 from static_analyzer.engine.models import SymbolInfo
+from static_analyzer.engine.progress import ProgressLogger
 from static_analyzer.engine.source_inspector import SourceInspector
 from static_analyzer.engine.symbol_table import SymbolTable
 from static_analyzer.engine.utils import definition_location, uri_to_path
@@ -62,7 +63,18 @@ class HierarchyBuilder:
             return hierarchy
 
         type_hierarchy_supported = False
+        # Why a line per round: one class at a time, JabRef's 2,701 took over half an hour without one.
+        pbar = ProgressLogger("Hierarchy", len(class_symbols), unit="type")
         for sym in class_symbols:
+            pbar.update(1)
+            # A class body on an enum constant subclasses its enum; preparing it lands on the constant, not a type.
+            # Its name is ``{...}``, dots and all, so the enum is what precedes the constant and it.
+            if [kind for _, kind in sym.parent_chain[-2:]] == [NodeType.ENUM, NodeType.ENUM_MEMBER]:
+                enum_name = sym.qualified_name.removesuffix(f".{sym.parent_chain[-1][0]}.{sym.name}")
+                if enum_name in hierarchy:
+                    hierarchy[sym.qualified_name]["superclasses"].append(enum_name)
+                    hierarchy[enum_name]["subclasses"].append(sym.qualified_name)
+                    continue
             try:
                 items = self._lsp.type_hierarchy_prepare(sym.file_path, sym.start_line, sym.start_char)
                 if not items:
@@ -70,8 +82,17 @@ class HierarchyBuilder:
                 type_hierarchy_supported = True
                 item = items[0]
 
+                # Supertypes alone: every class here is asked, so each subclass link is found from its subclass.
+                # Why not subtypes as well: JDTLS re-resolves every potential subtype for each, with every file
+                # open; on JabRef that was all but a minute of the half hour, for the same links.
                 try:
-                    supertypes = self._lsp.type_hierarchy_supertypes(item)
+                    prepared = self._resolve_type_hierarchy_item(item)
+                    if prepared is not None and prepared != sym.qualified_name:
+                        # An anonymous class is named by the type it instantiates, so preparing it lands on that
+                        # type, its base. Its supertypes would be the base's own.
+                        supertypes = [item]
+                    else:
+                        supertypes = self._lsp.type_hierarchy_supertypes(item)
                     for st in supertypes:
                         super_name = self._resolve_type_hierarchy_item(st)
                         if super_name and super_name in hierarchy:
@@ -83,26 +104,14 @@ class HierarchyBuilder:
                     pass
                 except Exception as e:
                     logger.debug("Failed to get supertypes for %s: %s", sym.qualified_name, e)
-
-                try:
-                    subtypes = self._lsp.type_hierarchy_subtypes(item)
-                    for st in subtypes:
-                        sub_name = self._resolve_type_hierarchy_item(st)
-                        if sub_name and sub_name in hierarchy:
-                            if sub_name not in hierarchy[sym.qualified_name]["subclasses"]:
-                                hierarchy[sym.qualified_name]["subclasses"].append(sub_name)
-                            if sym.qualified_name not in hierarchy[sub_name]["superclasses"]:
-                                hierarchy[sub_name]["superclasses"].append(sym.qualified_name)
-                except MethodNotFoundError:
-                    pass
-                except Exception as e:
-                    logger.debug("Failed to get subtypes for %s: %s", sym.qualified_name, e)
             except MethodNotFoundError:
                 logger.info("Type hierarchy not supported by server, skipping remaining classes")
                 break
             except Exception as e:
                 logger.debug("Type hierarchy not supported for %s: %s", sym.qualified_name, e)
 
+        pbar.finish()
+
         if not type_hierarchy_supported and self._adapter.resolves_bases_by_definition:
             logger.info("Type hierarchy not supported, resolving the bases written in source")
             self._resolve_bases_by_definition(class_symbols, hierarchy)
@@ -121,7 +130,9 @@ class HierarchyBuilder:
 
     def _resolve_type_hierarchy_item(self, item: dict) -> str | None:
         """Resolve a type hierarchy item to a qualified name in our symbol table."""
-        name = item.get("name", "")
+        # Names compare without type arguments: a supertype comes back as its use names it, ``TypeAdapter<Object>``,
+        # not as declared, ``TypeAdapter<T>``. Asking supertypes alone, that lost every link to a generic base.
+        name = item.get("name", "").split("<")[0]
         uri = item.get("uri", "")
         sel_range = item.get("selectionRange", item.get("range", {}))
         start = sel_range.get("start", {})
@@ -131,15 +142,20 @@ class HierarchyBuilder:
         if file_path is None:
             return None
 
-        file_key = str(file_path)
-        for sym in self._symbol_table.file_symbols.get(file_key, []):
-            if sym.name == name and sym.start_line == line:
+        symbols = self._symbol_table.file_symbols.get(str(file_path), [])
+        # The declaration's own position first: a name is not unique, every anonymous class in a file shares one.
+        for sym in symbols:
+            if self._adapter.is_class_like(sym.kind) and (sym.start_line, sym.start_char) == (
+                line,
+                start.get("character"),
+            ):
                 return sym.qualified_name
-            if sym.name == name and abs(sym.start_line - line) <= 1:
+        for sym in symbols:
+            if sym.name.split("<")[0] == name and abs(sym.start_line - line) <= 1:
                 return sym.qualified_name
 
-        for sym in self._symbol_table.file_symbols.get(file_key, []):
-            if sym.name == name and self._adapter.is_class_like(sym.kind):
+        for sym in symbols:
+            if sym.name.split("<")[0] == name and self._adapter.is_class_like(sym.kind):
                 return sym.qualified_name
         return None
 

{codeboarding-0.15.4 → codeboarding-0.15.5}/static_analyzer/engine/language_adapter.py

@@ -267,6 +267,11 @@ class LanguageAdapter(ABC):
         """Raise if a ready signal represents an unusable workspace state."""
         return None
 
+    @property
+    def search_index_timeout(self) -> int | None:
+        """Seconds the server's first search may take, for a server that builds its search index on it; None if not."""
+        return None
+
     def get_lsp_env(self, project_root: Path | None = None, source_files: Sequence[Path] = ()) -> dict[str, str]:
         """Return extra environment variables for the LSP server process.
 
@@ -401,6 +406,14 @@ class LanguageAdapter(ABC):
         neither ``textDocument/implementation`` nor ``typeHierarchy``."""
         return False
 
+    @property
+    def source_names_every_subtype(self) -> bool:
+        """Whether every type deriving from another names it in source, as
+        ``SourceInspector.find_derived_type_names`` reads it. Then a member of a
+        class nothing derives from is owed no ``textDocument/implementation``
+        query. Not so where inheritance is implicit (Go) or not yet read (TS)."""
+        return False
+
     @property
     def drain_probe_round_seconds(self) -> int | None:
         """Seconds after which the didOpen drain probe is asked again, or None to wait the whole budget

{codeboarding-0.15.4 → codeboarding-0.15.5}/static_analyzer/engine/lsp_client.py

@@ -33,6 +33,7 @@ LSP_STDERR_TAIL_LINES = 32
 # JSON AST nodes retain more Python objects than tree-sitter's native nodes.
 LSP_AST_NODE_BUDGET = 50_000
 LSP_METHOD_NOT_FOUND = -32601
+LSP_INTERNAL_ERROR = -32603
 # Codes LSP (-32899..-32800) and JSON-RPC (-32768..-32000) reserve for a request that went unserved;
 # any other code is the server declining for itself, as gopls does for a free function.
 LSP_RESERVED_ERROR_CODE_RANGES = ((-32899, -32800), (-32768, -32000))
@@ -923,6 +924,9 @@ class LSPClient:
                 continue
 
             pending.discard(msg_id)  # type: ignore[arg-type]
+            # The timeout is for a server gone quiet, not for the whole round: JDTLS answers a round one request
+            # at a time, and on JabRef 50 implementation queries took longer than it while answering throughout.
+            deadline = time.monotonic() + timeout
 
             if "error" in msg:
                 err = msg["error"]
@@ -943,7 +947,8 @@ class LSPClient:
                 if self._error_verdict is not None and isinstance(err, dict) and _is_protocol_failure(err):
                     verdict = self._error_verdict(err)
                 if _is_protocol_failure(err) and verdict is not ErrorVerdict.DECLINED:
-                    unserved[msg_id] = err_msg  # type: ignore[index]
+                    # The server's own trace is the only record of why; "Internal error." alone can't be diagnosed.
+                    unserved[msg_id] = f"{err_msg} {err['data']}" if err.get("data") else err_msg  # type: ignore[index]
                     if _is_retryable(err) or verdict is ErrorVerdict.TRANSIENT:
                         retryable.add(msg_id)  # type: ignore[arg-type]
                 else:

{codeboarding-0.15.4 → codeboarding-0.15.5}/static_analyzer/engine/protocols.py

@@ -46,6 +46,9 @@ class EdgeBuildAdapter(Protocol):
     @property
     def expands_virtual_dispatch(self) -> bool: ...
 
+    @property
+    def source_names_every_subtype(self) -> bool: ...
+
     @property
     def constructor_calls_resolve_to_class(self) -> bool: ...
 
@@ -61,6 +64,9 @@ class EdgeBuildAdapter(Protocol):
     @property
     def resolves_collection_initializers(self) -> bool: ...
 
+    @property
+    def search_index_timeout(self) -> int | None: ...
+
     def should_track_for_edges(self, symbol_kind: int) -> bool: ...
 
     def is_class_like(self, symbol_kind: int) -> bool: ...

{codeboarding-0.15.4 → codeboarding-0.15.5}/static_analyzer/engine/source_inspector.py

@@ -301,7 +301,7 @@ _KOTLIN_PARAMETER_LIST_NODE_TYPES = frozenset({"function_value_parameters"})
 _KOTLIN_PARAMETER_PART_NODE_TYPES = frozenset({"simple_identifier", "modifiers", "binding_pattern_kind"})
 _ARGUMENT_HOLDER_NODE_TYPES = frozenset({"call_expression", "constructor_invocation", "constructor_delegation_call"})
 _KOTLIN_DOC_COMMENT_NODE_TYPES = frozenset({"multiline_comment"})
-_KOTLIN_TYPE_ARGUMENTS = re.compile(r"<[^<>]*>")
+_TYPE_ARGUMENTS = re.compile(r"<[^<>]*>")
 # A package segment is lower case; an outer type's name before a nested one is kept, so
 # ``PublicKeyCredentialEntry.Builder`` and ``PasswordCredentialEntry.Builder`` stay apart.
 _KOTLIN_PACKAGE_QUALIFIER = re.compile(r"\b[a-z_][\w`]*\.(?=[\w`])")
@@ -1346,6 +1346,39 @@ class SourceInspector:
                 declarations.append((text(name_node), bases))
         return declarations
 
+    def find_derived_type_names(self, file_path: Path) -> set[str]:
+        """Every type name something in the file derives from.
+
+        That is a declared type's bases, the type an anonymous class body extends, and the enum a Java enum constant
+        with a body subclasses. Why: a member is only ever implemented in a type that derives from its owner, so an
+        owner no file names here has no implementation to ask the server for.
+        """
+        parsed = self._parse(file_path)
+        if parsed is None:
+            return set()
+
+        def simple_name(node: TreeSitterNode) -> str:
+            # ``Outer<T>.@Nullable Factory<Map.Entry<K, V>>`` names ``Factory``: drop the type arguments, innermost
+            # first, then the qualifier, then any annotation written before the name.
+            written = parsed.content[node.start_byte : node.end_byte].decode("utf8", "replace")
+            while _TYPE_ARGUMENTS.search(written):
+                written = _TYPE_ARGUMENTS.sub("", written)
+            return written.rsplit(".", 1)[-1].split()[-1]
+
+        names: set[str] = set()
+        for node in self._walk(parsed.tree.root_node):
+            if node.type in _TYPE_DECLARATION_NODE_TYPES:
+                names.update(simple_name(base) for base in self._base_type_nodes(node))
+            if not any(child.type == "class_body" for child in node.named_children):
+                continue
+            if node.type == "object_creation_expression" and (created := node.child_by_field_name("type")):
+                names.add(simple_name(created))
+            elif node.type == "enum_constant" and node.parent is not None and node.parent.parent is not None:
+                enum = node.parent.parent.child_by_field_name("name")
+                if enum is not None:
+                    names.add(simple_name(enum))
+        return names
+
     def find_base_type_sites(self, file_path: Path) -> list[tuple[tuple[int, int], list[tuple[int, int]]]]:
         """Each type the file declares, by its name's position, with the positions naming its bases.
 
@@ -1488,8 +1521,8 @@ class SourceInspector:
         def render_type(node: TreeSitterNode) -> str:
             # A function type's arrow is set aside first: its ``>`` would otherwise close a type argument.
             rendered = " ".join(text(node).split()).replace("->", "\0")
-            while _KOTLIN_TYPE_ARGUMENTS.search(rendered):
-                rendered = _KOTLIN_TYPE_ARGUMENTS.sub("", rendered)
+            while _TYPE_ARGUMENTS.search(rendered):
+                rendered = _TYPE_ARGUMENTS.sub("", rendered)
             return _KOTLIN_PACKAGE_QUALIFIER.sub("", rendered).replace("\0", "->")
 
         def parameter_types(node: TreeSitterNode, receiver: TreeSitterNode | None) -> str: