adl-toolkit 0.0.0-stage → 0.1.1

package/adl_drift/lang/java/detectors/__init__.py

@@ -0,0 +1,29 @@
+"""Java-specific registry detectors (P4.3)."""
+
+from adl_drift.lang.java.detectors.additional import (
+    JavaAnnotationDetector,
+    JavaAsyncDetector,
+    JavaConfigDetector,
+    JavaDynamicDetector,
+    JavaLoggingDetector,
+    JavaTypeDetector,
+)
+from adl_drift.lang.java.detectors.data_access import JavaDataAccessDetector
+from adl_drift.lang.java.detectors.imports import JavaImportDetector
+from adl_drift.lang.java.detectors.routes import JavaRouteDetector
+from adl_drift.lang.java.detectors.security import JavaSecurityDetector
+from adl_drift.lang.java.detectors.tests import JavaTestDetector
+
+__all__ = [
+    "JavaAnnotationDetector",
+    "JavaAsyncDetector",
+    "JavaConfigDetector",
+    "JavaDataAccessDetector",
+    "JavaDynamicDetector",
+    "JavaImportDetector",
+    "JavaLoggingDetector",
+    "JavaRouteDetector",
+    "JavaSecurityDetector",
+    "JavaTestDetector",
+    "JavaTypeDetector",
+]

package/adl_drift/lang/java/detectors/additional.py

@@ -0,0 +1,445 @@
+"""Small Java detectors for the lower-volume shared categories."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import re
+from typing import Dict, List, Optional, Set
+
+from tree_sitter import Node, Tree
+
+from adl_drift.lang.java.detectors.base import DeclaredTypes, JavaDetector
+from adl_drift.lang.java.scopes import TypeScopes
+from adl_drift.utils.types import Pattern, PatternCategory
+
+
+class JavaAnnotationDetector(JavaDetector):
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.DECORATORS
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        return [
+            self._make_pattern(
+                name="java_annotation",
+                description=f"Java annotation: @{self._annotation_name(node, source_bytes)}",
+                node=node,
+                file_path=file_path,
+                confidence=0.99,
+                metadata={
+                    "annotation": self._annotation_name(node, source_bytes),
+                    "reason": "Java annotation is explicit in source",
+                },
+            )
+            for node in self._walk(tree.root_node)
+            if node.type in ("annotation", "marker_annotation")
+        ]
+
+
+class JavaConfigDetector(JavaDetector):
+    SPRING_PACKAGE = "org.springframework.beans.factory.annotation.Value"
+    PROPERTIES_PACKAGE = "org.springframework.boot.context.properties.ConfigurationProperties"
+    RESOURCE_FILE = re.compile(
+        r"^(?:application|bootstrap)(?:-[A-Za-z0-9_.-]+)?\.(?:properties|ya?ml)$",
+        re.IGNORECASE,
+    )
+    SPRING_RESOURCE_CONSTRUCTORS = {
+        "org.springframework.core.io.ClassPathResource",
+        "org.springframework.core.io.FileSystemResource",
+    }
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.CONFIG
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        root = tree.root_node
+        imports = self._imports(root, source_bytes)
+        types = self._declared_types(root, source_bytes)
+        local_types = self._declared_type_names(root, source_bytes)
+        patterns: List[Pattern] = []
+        for node in self._walk(root):
+            if node.type == "method_invocation":
+                method = self._text(node.child_by_field_name("name"), source_bytes)
+                receiver = self._text(node.child_by_field_name("object"), source_bytes)
+                if method in {"getenv", "getProperty"} and self._type_has_provenance(
+                    receiver, imports, local_types, "java.lang.System", node
+                ):
+                    patterns.append(self._finding(
+                        "environment_read", node, file_path, 0.99,
+                        f"System.{method} reads external configuration", {"method": method},
+                    ))
+                resource = self._resource_invocation(
+                    node, source_bytes, types, imports, local_types
+                )
+                if resource:
+                    patterns.append(self._finding(
+                        "config_resource_read", node, file_path, 0.96,
+                        "Java resource API reads an application configuration file", resource,
+                    ))
+            elif node.type == "object_creation_expression":
+                resource = self._resource_constructor(node, source_bytes, imports, local_types)
+                if resource:
+                    patterns.append(self._finding(
+                        "config_resource_read", node, file_path, 0.97,
+                        "Spring resource object targets an application configuration file", resource,
+                    ))
+            elif node.type in ("field_declaration", "class_declaration", "record_declaration"):
+                for annotation in self._annotations(node):
+                    if self._annotation_is(annotation, source_bytes, imports, self.SPRING_PACKAGE):
+                        raw_keys = self._annotation_strings(annotation, source_bytes)
+                        patterns.append(self._finding(
+                            "spring_value", node, file_path, 0.99,
+                            "Field uses imported Spring @Value binding",
+                            {
+                                "keys": [self._normalize_key(key) for key in raw_keys],
+                                "raw_keys": raw_keys,
+                            },
+                        ))
+                    elif self._annotation_is(annotation, source_bytes, imports, self.PROPERTIES_PACKAGE):
+                        patterns.append(self._finding(
+                            "configuration_properties", node, file_path, 0.99,
+                            "Type uses imported Spring @ConfigurationProperties binding",
+                            {"prefix": (self._annotation_strings(annotation, source_bytes) or [""])[0]},
+                        ))
+        return patterns
+
+    def _resource_invocation(
+        self, node: Node, source: bytes, types: DeclaredTypes,
+        imports: Set[str], local_types: TypeScopes,
+    ) -> Optional[Dict[str, object]]:
+        resource_path = self._resource_path(node, source)
+        if not resource_path:
+            return None
+        method = self._text(node.child_by_field_name("name"), source)
+        receiver_node = node.child_by_field_name("object")
+        receiver = self._text(receiver_node, source)
+        declared = self._declared_type(receiver, types, node)
+        receiver_args = (
+            receiver_node.child_by_field_name("arguments")
+            if receiver_node is not None and receiver_node.type == "method_invocation"
+            else None
+        )
+        get_class_call = receiver_node is not None \
+            and receiver_node.type == "method_invocation" \
+            and self._text(receiver_node.child_by_field_name("name"), source) == "getClass" \
+            and receiver_args is not None and not receiver_args.named_children
+        class_resource = method in {"getResource", "getResourceAsStream"} and (
+            get_class_call or (receiver_node is not None and receiver_node.type == "class_literal")
+        )
+        classloader_resource = method in {
+            "getResource", "getResourceAsStream", "getSystemResource", "getSystemResourceAsStream",
+        } and (
+            self._type_has_provenance(
+                declared, imports, local_types, "java.lang.ClassLoader", node
+            ) or self._type_has_provenance(
+                receiver, imports, local_types, "java.lang.ClassLoader", node
+            )
+        )
+        spring_resource = method == "getResource" and self._type_has_provenance(
+            declared, imports, local_types, "org.springframework.core.io.ResourceLoader", node
+        )
+        if not (class_resource or classloader_resource or spring_resource):
+            return None
+        return {"resource": resource_path, "api": method}
+
+    def _resource_constructor(
+        self, node: Node, source: bytes, imports: Set[str], local_types: TypeScopes,
+    ) -> Optional[Dict[str, object]]:
+        resource_path = self._resource_path(node, source)
+        if not resource_path:
+            return None
+        raw_type = self._text(node.child_by_field_name("type"), source)
+        qualified = next(
+            (candidate for candidate in self.SPRING_RESOURCE_CONSTRUCTORS
+             if candidate.rsplit(".", 1)[-1] == self._simple_type(raw_type)),
+            "",
+        )
+        if not qualified or not self._type_has_provenance(
+            raw_type, imports, local_types, qualified, node
+        ):
+            return None
+        return {"resource": resource_path, "api": self._simple_type(raw_type)}
+
+    def _resource_path(self, node: Node, source: bytes) -> str:
+        argument = self._first_argument(node)
+        if argument is None or argument.type != "string_literal":
+            return ""
+        raw = self._text(argument, source)
+        value = raw[1:-1] if len(raw) >= 2 else ""
+        filename = value.rsplit("/", 1)[-1]
+        return value if self.RESOURCE_FILE.fullmatch(filename) else ""
+
+    @staticmethod
+    def _normalize_key(value: str) -> str:
+        key = value
+        if key.startswith("${") and key.endswith("}"):
+            key = key[2:-1].split(":", 1)[0]
+        key = re.sub(r"([a-z0-9])([A-Z])", r"\1-\2", key)
+        return key.replace("_", "-").lower()
+
+    def _finding(
+        self, name: str, node: Node, path: Path, confidence: float,
+        reason: str, extra: Dict[str, object],
+    ) -> Pattern:
+        return self._make_pattern(
+            name=name, description=reason, node=node, file_path=path,
+            confidence=confidence, metadata={"reason": reason, **extra},
+        )
+
+
+class JavaLoggingDetector(JavaDetector):
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.LOGGING
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        imports = self._imports(tree.root_node, source_bytes)
+        types = self._declared_types(tree.root_node, source_bytes)
+        local_types = self._declared_type_names(tree.root_node, source_bytes)
+        patterns: List[Pattern] = []
+        for node in self._walk(tree.root_node):
+            if node.type != "method_invocation":
+                continue
+            method = self._text(node.child_by_field_name("name"), source_bytes)
+            receiver = self._text(node.child_by_field_name("object"), source_bytes)
+            system_type, separator, stream = receiver.rpartition(".")
+            if separator and stream in {"out", "err"} and method.startswith("print") \
+                    and self._type_has_provenance(
+                        system_type, imports, local_types, "java.lang.System", node
+                    ):
+                patterns.append(self._finding(
+                    "system_output", node, file_path, 0.99,
+                    "Direct System.out/System.err output", {"stream": receiver},
+                ))
+            elif any(self._type_has_provenance(
+                    self._declared_type(receiver, types, node), imports, local_types,
+                    qualified, node,
+                ) for qualified in (
+                    "org.slf4j.Logger", "org.apache.logging.log4j.Logger",
+                    "org.apache.log4j.Logger", "java.util.logging.Logger",
+                )) \
+                    and method in {
+                "trace", "debug", "info", "warn", "error", "fatal", "log"
+            }:
+                first = self._first_argument(node)
+                eager = first is not None and first.type == "binary_expression"
+                patterns.append(self._finding(
+                    "logger_call", node, file_path, 0.95,
+                    "Call targets a declared logger",
+                    {"level": method, "eager_concatenation": eager},
+                ))
+        return patterns
+
+    def _finding(
+        self, name: str, node: Node, path: Path, confidence: float,
+        reason: str, extra: Dict[str, object],
+    ) -> Pattern:
+        return self._make_pattern(
+            name=name, description=reason, node=node, file_path=path,
+            confidence=confidence, metadata={"reason": reason, **extra},
+        )
+
+
+class JavaTypeDetector(JavaDetector):
+    RAW_TYPES = {"Collection", "List", "Set", "Map", "Optional", "Class"}
+    NULLABILITY_ANNOTATIONS = {
+        "org.jetbrains.annotations.Nullable": "nullable",
+        "org.jetbrains.annotations.NotNull": "non_null",
+        "jakarta.annotation.Nullable": "nullable",
+        "javax.annotation.Nullable": "nullable",
+        "jakarta.validation.constraints.NotNull": "non_null",
+        "javax.validation.constraints.NotNull": "non_null",
+        "org.springframework.lang.Nullable": "nullable",
+        "org.springframework.lang.NonNull": "non_null",
+        "org.jspecify.annotations.Nullable": "nullable",
+        "org.jspecify.annotations.NonNull": "non_null",
+        "org.jspecify.annotations.NullMarked": "non_null_by_default",
+        "org.jspecify.annotations.NullUnmarked": "unspecified_by_default",
+    }
+    NULLABILITY_TARGETS = {
+        "field_declaration": "field",
+        "local_variable_declaration": "local",
+        "formal_parameter": "parameter",
+        "method_declaration": "return",
+        "class_declaration": "type",
+        "interface_declaration": "type",
+        "record_declaration": "type",
+    }
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.TYPES
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        root = tree.root_node
+        imports = self._imports(root, source_bytes)
+        local_types = self._declared_type_names(root, source_bytes)
+        patterns: List[Pattern] = []
+        for node in self._walk(root):
+            if node.type in (
+                "field_declaration", "local_variable_declaration", "formal_parameter",
+                "method_declaration",
+            ):
+                type_node = node.child_by_field_name("type")
+                type_name = self._text(type_node, source_bytes)
+                simple = self._simple_type(type_name)
+                qualified = f"java.lang.{simple}" if simple == "Class" else f"java.util.{simple}"
+                if "<" not in type_name and simple in self.RAW_TYPES and self._type_has_provenance(
+                    type_name, imports, local_types, qualified, node
+                ):
+                    patterns.append(self._make_pattern(
+                        name="raw_generic_type",
+                        description=f"Raw generic type: {type_name}",
+                        node=type_node or node,
+                        file_path=file_path,
+                        confidence=0.98,
+                        metadata={
+                            "type": type_name,
+                            "reason": "Imported generic JDK type is used without type arguments",
+                        },
+                    ))
+            target_kind = self.NULLABILITY_TARGETS.get(node.type)
+            if not target_kind:
+                continue
+            for annotation in self._annotations(node):
+                for qualified, nullability in self.NULLABILITY_ANNOTATIONS.items():
+                    if not self._annotation_is(annotation, source_bytes, imports, qualified):
+                        continue
+                    patterns.append(self._make_pattern(
+                        name="nullability_annotation",
+                        description=f"Java nullability contract: {nullability}",
+                        node=annotation,
+                        file_path=file_path,
+                        confidence=0.99,
+                        metadata={
+                            "nullability": nullability,
+                            "target_kind": target_kind,
+                            "annotation_fqn": qualified,
+                            "reason": "Imported or fully-qualified nullability annotation",
+                        },
+                    ))
+                    break
+        return patterns
+
+
+class JavaAsyncDetector(JavaDetector):
+    SPRING_ASYNC = "org.springframework.scheduling.annotation.Async"
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.ASYNC
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        root = tree.root_node
+        imports = self._imports(root, source_bytes)
+        types = self._declared_types(root, source_bytes)
+        local_types = self._declared_type_names(root, source_bytes)
+        patterns: List[Pattern] = []
+        for node in self._walk(root):
+            if node.type == "method_declaration" and any(
+                self._annotation_is(a, source_bytes, imports, self.SPRING_ASYNC)
+                for a in self._annotations(node)
+            ):
+                patterns.append(self._finding(
+                    "spring_async", node, file_path, 0.99, "Method uses imported Spring @Async",
+                ))
+            elif node.type == "object_creation_expression" and self._type_has_provenance(
+                self._text(node.child_by_field_name("type"), source_bytes),
+                imports, local_types, "java.lang.Thread", node,
+            ):
+                patterns.append(self._finding(
+                    "raw_thread", node, file_path, 0.95, "Code constructs a raw java.lang.Thread",
+                ))
+            elif node.type == "method_invocation":
+                method = self._text(node.child_by_field_name("name"), source_bytes)
+                receiver = self._text(node.child_by_field_name("object"), source_bytes)
+                raw_receiver_type = self._declared_type(receiver, types, node)
+                executor_type = self._simple_type(raw_receiver_type)
+                if method in {"submit", "execute", "invokeAll"} and executor_type in {
+                    "Executor", "ExecutorService",
+                } and self._type_has_provenance(
+                    raw_receiver_type, imports, local_types,
+                    f"java.util.concurrent.{executor_type}", node,
+                ):
+                    patterns.append(self._finding(
+                        "executor_task", node, file_path, 0.95,
+                        "Declared Executor/ExecutorService schedules work",
+                    ))
+                elif method in {
+                    "runAsync", "supplyAsync", "completedFuture", "allOf", "anyOf",
+                } and self._type_has_provenance(
+                    receiver, imports, local_types,
+                    "java.util.concurrent.CompletableFuture", node,
+                ):
+                    patterns.append(self._finding(
+                        "completable_future", node, file_path, 0.98,
+                        "CompletableFuture schedules or composes asynchronous work",
+                    ))
+                elif method in {
+                    "thenApplyAsync", "thenAcceptAsync", "thenRunAsync", "handleAsync",
+                    "whenCompleteAsync",
+                } and self._type_has_provenance(
+                    self._declared_type(receiver, types, node), imports, local_types,
+                    "java.util.concurrent.CompletableFuture", node,
+                ):
+                    patterns.append(self._finding(
+                        "completable_future", node, file_path, 0.96,
+                        "Declared CompletableFuture composes asynchronous work",
+                    ))
+        return patterns
+
+    def _finding(
+        self, name: str, node: Node, path: Path, confidence: float, reason: str
+    ) -> Pattern:
+        return self._make_pattern(
+            name=name, description=reason, node=node, file_path=path,
+            confidence=confidence, metadata={"reason": reason},
+        )
+
+
+class JavaDynamicDetector(JavaDetector):
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.DYNAMIC
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        imports = self._imports(tree.root_node, source_bytes)
+        types = self._declared_types(tree.root_node, source_bytes)
+        local_types = self._declared_type_names(tree.root_node, source_bytes)
+        patterns: List[Pattern] = []
+        for node in self._walk(tree.root_node):
+            if node.type != "method_invocation":
+                continue
+            method = self._text(node.child_by_field_name("name"), source_bytes)
+            receiver = self._text(node.child_by_field_name("object"), source_bytes)
+            name: Optional[str] = None
+            reason = ""
+            confidence = 0.9
+            if method == "forName" and self._type_has_provenance(
+                receiver, imports, local_types, "java.lang.Class", node
+            ):
+                name, reason, confidence = "class_for_name", "Class.forName resolves a type at runtime", 0.98
+            elif method in {"getMethod", "getDeclaredMethod", "getField", "getDeclaredField"} \
+                    and (receiver.endswith("getClass()")
+                         or self._type_has_provenance(
+                             self._declared_type(receiver, types, node), imports,
+                             local_types, "java.lang.Class", node,
+                         )):
+                name, reason = "reflective_lookup", "Member name is resolved through Java reflection"
+            elif method == "invoke" and self._has_import(imports, "java.lang.reflect.Method") \
+                    and self._type_has_provenance(
+                        self._declared_type(receiver, types, node), imports, local_types,
+                        "java.lang.reflect.Method", node,
+                    ):
+                name, reason, confidence = "reflective_invoke", "Declared java.lang.reflect.Method is invoked", 0.96
+            elif method == "newProxyInstance" and self._type_has_provenance(
+                    receiver, imports, local_types, "java.lang.reflect.Proxy", node):
+                name, reason, confidence = "dynamic_proxy", "java.lang.reflect.Proxy creates runtime dispatch", 0.98
+            if name:
+                patterns.append(self._make_pattern(
+                    name=name, description=reason, node=node, file_path=file_path,
+                    confidence=confidence,
+                    metadata={"resolvable": "partial", "reason": reason},
+                ))
+        return patterns

package/adl_drift/lang/java/detectors/base.py

@@ -0,0 +1,154 @@
+"""Small CST helpers shared by Java detectors.
+
+Import/declared-type provenance matching (`_imports`/`_declared_types`/
+`_type_has_provenance`/`_annotation_is`) delegates to `lang/java/
+type_provenance.py`, which P4.6's Java taint layer also uses directly
+against a per-file `JavaTypeContext` — this class's methods are thin
+wrappers kept for its many existing detector call sites, not a second
+implementation.
+
+`_imports`/`_declared_types`/`_declared_type_names` are memoized per file
+(P8 Phase 2): up to 11 detector instances each call these at the top of
+their own `detect()`, and `_annotation_is` (below) calls
+`_declared_type_names` again on every single annotation check — profiling
+showed this re-walking the same file's CST 20-30x instead of once. The
+cache is a single-slot `threading.local()`, keyed by `root.id` — tree-sitter
+Node objects are rewrapped on every attribute access (`tree.root_node is
+tree.root_node` is `False`), so Python `is`/`id()` can't identify "same
+underlying node" across the separate `tree.root_node` fetches each detector
+makes; `root.id` is tree-sitter's own identifier for the underlying node and
+*is* stable across those rewraps. `root.id` is itself address-derived and
+in principle reusable once its tree is freed, but the slot also holds a
+strong reference to the `root` it last cached (`_file_cache.root`) — as
+long as that reference is live, its tree can't be freed, so its id can't be
+handed to an unrelated new tree; the id can only repeat once the slot has
+already moved on to caching something else. The cache naturally resets when
+`DetectorRegistry.run_all()` moves to the next file, and stays correctly
+isolated per worker under every `scanner/parallel.py` execution tier: a
+fresh interpreter (and thread-local) per `ProcessPoolExecutor` worker, a
+genuinely separate slot per `ThreadPoolExecutor` thread, and a single slot
+reused file-by-file when sequential."""
+
+from __future__ import annotations
+
+import ast
+import threading
+from typing import Iterator, List, Optional, Set
+
+from tree_sitter import Node
+
+from adl_drift.detectors.base import BaseDetector
+from adl_drift.lang.java import type_provenance as _tp
+from adl_drift.lang.java.scopes import TYPE_DECLARATIONS, TypeScopes, declared_type_scopes
+
+ANNOTATION_TYPES = ("annotation", "marker_annotation")
+DECLARATION_TYPES = _tp._DECLARATION_TYPES
+CLASS_TYPES = tuple(TYPE_DECLARATIONS)
+SCOPE_TYPES = _tp._SCOPE_TYPES
+DeclaredTypes = _tp.DeclaredTypes
+
+_file_cache = threading.local()
+
+
+def _cache_for(root: Node) -> threading.local:
+    if getattr(_file_cache, "root_id", None) != root.id:
+        _file_cache.root_id = root.id
+        _file_cache.root = root
+        _file_cache.imports = None
+        _file_cache.declared_types = None
+        _file_cache.local_types = None
+    return _file_cache
+
+
+class JavaDetector(BaseDetector):
+    def _walk(self, node: Node) -> Iterator[Node]:
+        yield node
+        for child in node.children:
+            yield from self._walk(child)
+
+    def _text(self, node: Optional[Node], source: bytes) -> str:
+        return self.parser.node_text(node, source).strip() if node is not None else ""
+
+    def _annotations(self, node: Node) -> List[Node]:
+        modifiers = next((c for c in node.children if c.type == "modifiers"), None)
+        return [c for c in modifiers.children if c.type in ANNOTATION_TYPES] if modifiers else []
+
+    def _annotation_name(self, annotation: Node, source: bytes) -> str:
+        return self._text(annotation.child_by_field_name("name"), source)
+
+    def _annotation_strings(self, annotation: Node, source: bytes) -> List[str]:
+        values: List[str] = []
+        for node in self._walk(annotation):
+            if node.type != "string_literal":
+                continue
+            raw = self._text(node, source)
+            try:
+                values.append(ast.literal_eval(raw))
+            except (SyntaxError, ValueError):
+                values.append(raw.strip('"'))
+        return values
+
+    def _imports(self, root: Node, source: bytes) -> Set[str]:
+        cache = _cache_for(root)
+        if cache.imports is None:
+            cache.imports = _tp.imports_of(root, source)
+        return cache.imports
+
+    @staticmethod
+    def _has_import(imports: Set[str], qualified_name: str) -> bool:
+        return _tp.has_import(imports, qualified_name)
+
+    def _annotation_is(
+        self, annotation: Node, source: bytes, imports: Set[str], qualified_name: str
+    ) -> bool:
+        name = self._annotation_name(annotation, source)
+        root = annotation
+        while root.parent is not None:
+            root = root.parent
+        local_types = self._declared_type_names(root, source)
+        return _tp.annotation_is(name, annotation.start_byte, imports, local_types, qualified_name)
+
+    def _declared_types(self, root: Node, source: bytes) -> DeclaredTypes:
+        cache = _cache_for(root)
+        if cache.declared_types is None:
+            cache.declared_types = _tp.declared_types_of(root, source)
+        return cache.declared_types
+
+    @staticmethod
+    def _typed_declaration_scope(node: Node) -> Optional[Node]:
+        return _tp._typed_declaration_scope(node)
+
+    @staticmethod
+    def _declaration_scope(node: Node) -> Node:
+        return _tp._declaration_scope(node)
+
+    def _declared_type(self, receiver: str, types: DeclaredTypes, at: Node) -> str:
+        return _tp.declared_type_of(receiver, types, at.start_byte)
+
+    def _declared_type_names(self, root: Node, source: bytes) -> TypeScopes:
+        cache = _cache_for(root)
+        if cache.local_types is None:
+            cache.local_types = declared_type_scopes(root, source)
+        return cache.local_types
+
+    @staticmethod
+    def _simple_type(type_name: str) -> str:
+        return _tp.simple_type(type_name)
+
+    def _type_has_provenance(
+        self, raw_type: str, imports: Set[str], local_types: TypeScopes,
+        qualified_name: str, at: Node,
+    ) -> bool:
+        return _tp.type_has_provenance(raw_type, imports, local_types, qualified_name, at.start_byte)
+
+    def _first_argument(self, invocation: Node) -> Optional[Node]:
+        args = invocation.child_by_field_name("arguments")
+        if args is None:
+            return None
+        return next((c for c in args.named_children if not c.is_extra), None)
+
+    def _package(self, root: Node, source: bytes) -> str:
+        for node in root.named_children:
+            if node.type == "package_declaration":
+                return self._text(node.named_children[-1], source)
+        return "<default>"