adl-toolkit 0.0.0-stage → 0.1.1

package/adl_drift/lang/java/resolution/generated.py

@@ -0,0 +1,95 @@
+"""Synthetic Java members required by language and annotation semantics."""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+from adl_drift.graph.edges import EdgeType, GraphEdge
+from adl_drift.graph.node import GraphNode, NodeType
+
+
+class GeneratedMembersMixin:
+    def _ensure_generated_member_stubs(self) -> Dict[str, List[str]]:
+        """Materialize mandatory enum methods and record accessors.
+
+        The extractor correctly records only source declarations, while enum
+        ``values``/``valueOf`` and record component accessors are generated by
+        the compiler and therefore have no CST method declaration. Resolution
+        still needs real FUNCTION targets, so create only these language-
+        mandated members, with deterministic ids and normal CONTAINS edges.
+        """
+        created: Dict[str, List[str]] = {}
+        type_nodes = [
+            node for node in list(self.builder._nodes.values())
+            if node.language == "java"
+            and node.node_type == NodeType.CLASS
+            and node.metadata.get("java_type_kind") in {"enum", "record"}
+        ]
+        for type_node in type_nodes:
+            kind = type_node.metadata.get("java_type_kind")
+            # Keep the enclosing type path for nested enums.  Returning only
+            # `Status[]` from `EventPublication.Status.values()` loses the
+            # owner and can become ambiguous (or unresolvable) at callers in
+            # another nested class.  The portion after the module separator is
+            # the source qualname accepted by `_resolve_declared_type`.
+            enum_type = type_node.id.rsplit(":", 1)[-1]
+            methods = (
+                [("values", [], f"{enum_type}[]", True),
+                 ("valueOf", ["String"], enum_type, True)]
+                if kind == "enum"
+                else [
+                    (name, [], str(component_type), False)
+                    for name, component_type in dict(
+                        type_node.metadata.get("record_components", {})
+                    ).items()
+                ]
+            )
+            for name, params, return_type, is_static in methods:
+                signature_key = f"({','.join(params)})"
+                stub_id = f"{type_node.id}.{name}{signature_key}"
+                self._add_generated_member_stub(
+                    type_node, stub_id, name, params, return_type, is_static,
+                )
+                created[stub_id] = params
+        return created
+
+    def _add_generated_member_stub(
+        self, type_node: GraphNode, stub_id: str, name: str,
+        params: List[str], return_type: str, is_static: bool,
+    ) -> None:
+        if stub_id not in self.builder._nodes:
+            signature_key = f"({','.join(params)})"
+            marker = (
+                "java_synthetic_enum_method"
+                if type_node.metadata.get("java_type_kind") == "enum"
+                else "java_synthetic_record_accessor"
+            )
+            self.builder._add_node(GraphNode(
+                    id=stub_id,
+                    name=name,
+                    node_type=NodeType.FUNCTION,
+                    module=type_node.module,
+                    file_path=type_node.file_path,
+                    line=type_node.line,
+                    column=type_node.column,
+                    signature=f"{return_type} {name}{signature_key}",
+                    contained_in=type_node.name,
+                    language="java",
+                    metadata={
+                        "java_is_static": is_static,
+                        "java_is_abstract": False,
+                        "java_return_type": return_type,
+                        marker: True,
+                    },
+            ))
+            self.builder._add_edge(GraphEdge(
+                    source=type_node.id,
+                    target=stub_id,
+                    edge_type=EdgeType.CONTAINS,
+                    file_path=type_node.file_path,
+                    line=type_node.line,
+                    column=type_node.column,
+                    strategy="java_resolver",
+            ))
+
+    # ------------------------------------------------------------------ CST utilities

package/adl_drift/lang/java/resolution/model.py

@@ -0,0 +1,153 @@
+"""Shared data models for Java call resolution.
+
+These types deliberately contain no graph traversal or resolution policy.  Keeping
+them in a dependency-leaf module lets the resolver's specialized components share
+context without importing the orchestration class.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Dict, FrozenSet, List, NamedTuple, Optional, Tuple
+
+
+class SAMDescriptor(NamedTuple):
+    params: List[str]
+    return_type: Optional[str]
+
+
+class BeanCandidate(NamedTuple):
+    """One concrete Spring bean that can satisfy an injected interface."""
+
+    type_id: str
+    bean_name: Optional[str]
+    qualifiers: FrozenSet[str]
+    primary: bool
+    source: str
+
+
+class InjectedFieldMetadata(NamedTuple):
+    """DI metadata inferred for a field from constructor or setter injection."""
+
+    qualifier: Optional[str]
+    source: str
+
+
+class DINarrowResult(NamedTuple):
+    """Result of Spring DI narrowing for an injected interface receiver."""
+
+    target: Optional[str]
+    confidence: float
+    strategy: str
+
+
+class ImportContext(NamedTuple):
+    """One source file's Java name-resolution context.
+
+    `enclosing_class_id` (optional, defaults to `None` for every pre-existing
+    construction site) is the CLASS node id whose body this context resolves
+    names *for* — the caller's own class for a call-site's argument context,
+    or a candidate method's declaring class for its parameter context. It
+    lets `_resolve_declared_type` look up a bare type name inherited from a
+    superclass/superinterface (JLS 6.4.1), which needs the referencing
+    class's own supertype chain, not just its module/imports."""
+
+    module: str
+    import_map: Dict[str, str]
+    wildcard_packages: List[str]
+    enclosing_class_id: Optional[str] = None
+
+
+class LocalScopes:
+    """Lexically-scoped local-variable and allocation types for one body."""
+
+    __slots__ = ("_by_name", "_allocation_by_name", "_declared_by_name")
+
+    def __init__(self) -> None:
+        self._by_name: Dict[str, List[Tuple[str, int, int]]] = defaultdict(list)
+        self._allocation_by_name: Dict[
+            str, List[Tuple[str, int, int]]
+        ] = defaultdict(list)
+        self._declared_by_name: Dict[str, List[Tuple[int, int]]] = defaultdict(list)
+
+    def add(self, name: str, type_text: str, start: int, end: int) -> None:
+        # Multiple inference passes may describe the same declaration range:
+        # the early fluent-lambda pass can seed a placeholder type variable
+        # (`E`), then SAM target typing refines it to `SomeEvent`.  The later,
+        # more contextual fact must replace—not sit behind—the placeholder.
+        self._by_name[name] = [
+            entry for entry in self._by_name[name]
+            if entry[1] != start or entry[2] != end
+        ]
+        self._by_name[name].append((type_text, start, end))
+        # A `var`'s first pass (`_collect_local_scopes`) may have recorded
+        # this exact range as "declared, type unknown" before a later,
+        # context-aware pass (`_collect_var_method_call_scopes`) resolved its
+        # real type — that placeholder must not outrank the now-known type
+        # in `type_at` just because it shares the same range.
+        if name in self._declared_by_name:
+            self._declared_by_name[name] = [
+                entry for entry in self._declared_by_name[name]
+                if entry[0] != start or entry[1] != end
+            ]
+
+    def type_at(self, name: str, offset: int) -> Optional[str]:
+        best_type: Optional[str] = None
+        best_start = -1
+        for type_text, start, end in self._by_name.get(name, ()):
+            # Equal starts arise when a later contextual pass refines the
+            # same lambda parameter with a slightly different end boundary.
+            # Iteration order is inference order, so the later fact wins.
+            if start <= offset <= end and start >= best_start:
+                best_type, best_start = type_text, start
+        for start, end in self._declared_by_name.get(name, ()):
+            # A declared-but-type-unknown entry (a lambda parameter whose
+            # SAM type couldn't be inferred, or a `var` local whose
+            # initializer type couldn't be resolved) still shadows an outer
+            # typed declaration of the same name when it is the innermost
+            # match — the outer type must not leak into a nested scope it
+            # isn't actually visible from (P4.4 shadow-detection fix).
+            if start <= offset <= end and start >= best_start:
+                best_type, best_start = None, start
+        return best_type
+
+    def add_declared(self, name: str, start: int, end: int) -> None:
+        """Record that `name` is a local whose type could not be resolved
+        (e.g. a `var` initialized from an unresolvable expression). `add()`
+        is skipped for these — there is no type to record — but callers that
+        only need "is this name shadowed by *some* local declaration here",
+        not its type, must still see it (P4.4 shadow-detection fix)."""
+        self._declared_by_name[name].append((start, end))
+
+    def declared_at(self, name: str, offset: int) -> bool:
+        return any(
+            start <= offset <= end
+            for start, end in self._declared_by_name.get(name, ())
+        )
+
+    def add_allocation(self, name: str, type_text: str, start: int, end: int) -> None:
+        self._allocation_by_name[name].append((type_text, start, end))
+
+    def allocation_type_at(self, name: str, offset: int) -> Optional[str]:
+        best_type: Optional[str] = None
+        best_start = -1
+        for type_text, start, end in self._allocation_by_name.get(name, ()):
+            if start <= offset <= end and start > best_start:
+                best_type, best_start = type_text, start
+        return best_type
+
+
+class MethodFacts(NamedTuple):
+    """Immutable CST facts shared by one Java method body in one resolve run.
+
+    Call sites, method references, and scope declarations all used to require
+    separate body DFS walks.  This object intentionally carries syntax facts
+    only: scope/type inference and target resolution keep their existing
+    semantics and mutable per-caller state.
+    """
+
+    call_sites: Tuple[Tuple[object, str], ...]
+    method_references: Tuple[object, ...]
+    assignment_expressions: Tuple[object, ...]
+    local_scope_nodes: Tuple[object, ...]
+    lambda_expressions: Tuple[object, ...]