codemap-java 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

codemap_java/indexer.py

@@ -5,8 +5,17 @@ declarations. Package declarations are honoured as a namespace prefix
 under the file path. Nested types track a class stack to produce the
 correct ``Cls#Inner#m()`` chain.
 
-The indexer is single-file by design; cross-file `extends` / `implements`
-resolution lives in a future bridge so the indexer surface stays narrow.
+The indexer is single-file by design; cross-file ``extends`` / ``implements``
+and call-graph resolution lives in :class:`codemap.core.bridge.java_calls
+.JavaCallResolverBridge`. To enable that resolver, the indexer attaches three
+metadata keys to ``Symbol.extra`` (ADR-0013):
+
+* top-level type symbols carry ``imports`` (list[str], fully qualified)
+* top-level type symbols carry ``supertypes`` (list of
+  ``{"name": str, "relation": "extends"|"implements"}``)
+* method / constructor symbols carry ``pending_calls`` — a list of raw
+  invocation records ``{"receiver", "name", "arity", "line", "col"}`` for
+  the bridge to FQN-resolve.
 """
 
 from __future__ import annotations
@@ -17,7 +26,7 @@ from typing import ClassVar
 import tree_sitter
 import tree_sitter_java
 
-from codemap.core.models import Diagnostic, Edge, IndexResult, Range, Symbol
+from codemap.core.models import Annotation, Diagnostic, Edge, IndexResult, Range, Symbol
 from codemap.core.symbol import Descriptor, DescriptorKind, SymbolID
 from codemap.indexers.base import IndexContext
 
@@ -100,12 +109,19 @@ class _Visitor:
         self.edges: list[Edge] = []
         self.diagnostics: list[Diagnostic] = []
         self._class_stack: list[str] = []
+        self._class_annos_stack: list[list[Annotation]] = []
         self._package: str = ""
+        self._file_imports: list[str] = []
 
     def visit(self, node: tree_sitter.Node) -> None:
         if node.type == "package_declaration":
             self._package = _node_text(node.children[1]) if node.child_count > 1 else ""
             return
+        if node.type == "import_declaration":
+            imp = _parse_import(node)
+            if imp:
+                self._file_imports.append(imp)
+            return
         if node.type in _TYPE_DECLS:
             self._visit_type(node)
             return
@@ -128,7 +144,16 @@ class _Visitor:
         if name is None:
             return
         java_kind = node.type.removesuffix("_declaration")
+        is_top_level = not self._class_stack
         sid = self._make_id(name, kind=DescriptorKind.TYPE)
+        annotations = _parse_annotations(node)
+        extra: dict[str, object] = {}
+        if self._package or java_kind != "class":
+            extra["java_kind"] = java_kind
+            extra["package"] = self._package
+        if is_top_level:
+            extra["imports"] = list(self._file_imports)
+            extra["supertypes"] = _parse_supertypes(node)
         self.symbols.append(
             Symbol(
                 id=sid,
@@ -136,20 +161,21 @@ class _Visitor:
                 language=LANG,
                 file=self.relative_path,
                 range=_node_range(node),
-                extra={"java_kind": java_kind, "package": self._package}
-                if self._package or java_kind != "class"
-                else {},
+                annotations=annotations,
+                extra=extra,
             )
         )
         body = node.child_by_field_name("body")
         if body is None:
             return
         self._class_stack.append(name)
+        self._class_annos_stack.append(annotations)
         try:
             for child in body.children:
                 self.visit(child)
         finally:
             self._class_stack.pop()
+            self._class_annos_stack.pop()
 
     # ----------------------------------------------------------- members
 
@@ -164,6 +190,21 @@ class _Visitor:
             display = name
             sid = self._make_id(name, kind=DescriptorKind.METHOD)
         signature = _method_signature(node, name, is_constructor=is_constructor)
+        body = node.child_by_field_name("body")
+        pending_calls = _collect_invocations(body) if body is not None else []
+        params = _parse_formal_parameters(node.child_by_field_name("parameters"))
+        method_annos = _parse_annotations(node)
+        extra: dict[str, object] = {"params": params}
+        if not is_constructor:
+            ret = node.child_by_field_name("type")
+            if ret is not None:
+                extra["return_type"] = _strip_generics(_node_text(ret))
+        if pending_calls:
+            extra["pending_calls"] = pending_calls
+        class_annos = self._class_annos_stack[-1] if self._class_annos_stack else []
+        route = _http_route_meta(class_annos, method_annos)
+        if route is not None:
+            extra["http_route"] = route
         self.symbols.append(
             Symbol(
                 id=sid,
@@ -172,10 +213,14 @@ class _Visitor:
                 file=self.relative_path,
                 range=_node_range(node),
                 signature=signature,
+                annotations=method_annos,
+                extra=extra,
             )
         )
 
     def _visit_field(self, node: tree_sitter.Node) -> None:
+        type_node = node.child_by_field_name("type")
+        type_str = _strip_generics(_node_text(type_node)) if type_node is not None else ""
         for child in node.children:
             if child.type != "variable_declarator":
                 continue
@@ -186,6 +231,9 @@ class _Visitor:
             if not name:
                 continue
             sid = self._make_id(name, kind=DescriptorKind.TERM)
+            extra: dict[str, object] = {}
+            if type_str:
+                extra["type"] = type_str
             self.symbols.append(
                 Symbol(
                     id=sid,
@@ -193,6 +241,7 @@ class _Visitor:
                     language=LANG,
                     file=self.relative_path,
                     range=_node_range(child),
+                    extra=extra,
                 )
             )
 
@@ -252,3 +301,289 @@ def _method_signature(
     return_type = node.child_by_field_name("type")
     rt_text = _node_text(return_type) + " " if return_type is not None else ""
     return f"{rt_text}{name}{params_text}"
+
+
+# ---------------------------------------------------------------------------
+# Metadata extractors for the JavaCallResolverBridge (ADR-0013)
+# ---------------------------------------------------------------------------
+
+
+def _parse_import(node: tree_sitter.Node) -> str:
+    """Return the imported FQN. ``import static x.y.Z.m;`` → ``x.y.Z.m``;
+    ``import java.util.*;`` → ``java.util.*``. Empty string on malformed
+    input (returned to the caller, who drops empties)."""
+    parts: list[str] = []
+    saw_asterisk = False
+    for child in node.children:
+        ttype = child.type
+        if ttype in {"import", "static", ";"}:
+            continue
+        if ttype == "asterisk":
+            saw_asterisk = True
+            continue
+        if ttype in {"identifier", "scoped_identifier"}:
+            parts.append(_node_text(child))
+    if not parts:
+        return ""
+    path = ".".join(parts)
+    return f"{path}.*" if saw_asterisk else path
+
+
+def _parse_supertypes(type_node: tree_sitter.Node) -> list[dict[str, str]]:
+    """Extract ``extends`` / ``implements`` relations off a type declaration.
+
+    Handles ``class X extends A``, ``class X implements I, J``,
+    ``class X extends A implements I``, and ``interface I extends J, K``.
+    Generic type arguments (``Box<String>``) are stripped — bridge resolves
+    by raw name, not parameterized type.
+    """
+    out: list[dict[str, str]] = []
+    for child in type_node.children:
+        ttype = child.type
+        # `class` declarations: superclass / super_interfaces fields.
+        if ttype == "superclass":
+            out.extend({"name": name, "relation": "extends"} for name in _supertype_names(child))
+        elif ttype == "super_interfaces":
+            out.extend({"name": name, "relation": "implements"} for name in _supertype_names(child))
+        # `interface` declarations: extends_interfaces.
+        elif ttype == "extends_interfaces":
+            out.extend({"name": name, "relation": "extends"} for name in _supertype_names(child))
+    return out
+
+
+def _supertype_names(container: tree_sitter.Node) -> list[str]:
+    out: list[str] = []
+    for child in container.children:
+        ttype = child.type
+        if ttype in {"type_identifier", "scoped_type_identifier"}:
+            out.append(_node_text(child))
+        elif ttype == "generic_type":
+            # take the head type, drop ``<...>``
+            head = child.child(0)
+            if head is not None and head.type in {
+                "type_identifier",
+                "scoped_type_identifier",
+            }:
+                out.append(_node_text(head))
+        elif ttype == "type_list":
+            out.extend(_supertype_names(child))
+    return out
+
+
+def _collect_invocations(body: tree_sitter.Node) -> list[dict[str, object]]:
+    """Walk ``body`` collecting every ``method_invocation`` node as a raw
+    record. The bridge does FQN resolution; here we only capture the syntactic
+    shape (receiver text, name, arity, location)."""
+    records: list[dict[str, object]] = []
+
+    def walk(node: tree_sitter.Node) -> None:
+        if node.type == "method_invocation":
+            name_node = node.child_by_field_name("name")
+            obj_node = node.child_by_field_name("object")
+            args_node = node.child_by_field_name("arguments")
+            if name_node is not None:
+                receiver = _receiver_text(obj_node)
+                name = _node_text(name_node)
+                arity = _argument_arity(args_node)
+                sr, sc = node.start_point
+                records.append(
+                    {
+                        "receiver": receiver,
+                        "name": name,
+                        "arity": arity,
+                        "line": sr + 1,
+                        "col": sc,
+                    }
+                )
+        for child in node.children:
+            walk(child)
+
+    walk(body)
+    return records
+
+
+def _receiver_text(obj: tree_sitter.Node | None) -> str:
+    """Best-effort textual receiver. Empty for unqualified calls; the inner
+    method's name for chained calls (``foo.bar().baz()`` → ``"bar"`` is the
+    receiver of ``baz``)."""
+    if obj is None:
+        return ""
+    ttype = obj.type
+    if ttype in {"identifier", "scoped_identifier", "this", "super"}:
+        return _node_text(obj)
+    if ttype == "field_access":
+        field = obj.child_by_field_name("field")
+        return _node_text(field) if field is not None else ""
+    if ttype == "method_invocation":
+        inner = obj.child_by_field_name("name")
+        return _node_text(inner) if inner is not None else ""
+    return ""
+
+
+def _argument_arity(args: tree_sitter.Node | None) -> int:
+    if args is None:
+        return 0
+    # named_child_count skips punctuation tokens (`(`, `)`, `,`).
+    return int(args.named_child_count)
+
+
+def _parse_formal_parameters(node: tree_sitter.Node | None) -> list[dict[str, str]]:
+    """Return ``[{"name": str, "type": str}]`` for each formal parameter.
+
+    Generic type arguments are stripped (``List<String>`` → ``List``) so the
+    FQN resolver can match by raw type name.
+    """
+    if node is None:
+        return []
+    out: list[dict[str, str]] = []
+    for child in node.children:
+        if child.type not in {"formal_parameter", "spread_parameter"}:
+            continue
+        name_node = child.child_by_field_name("name")
+        type_node = child.child_by_field_name("type")
+        if name_node is None or type_node is None:
+            # Spread parameters wrap the actual variable_declarator differently.
+            for sub in child.children:
+                if sub.type == "variable_declarator" and name_node is None:
+                    name_node = sub.child_by_field_name("name")
+        if name_node is None or type_node is None:
+            continue
+        out.append(
+            {
+                "name": _node_text(name_node),
+                "type": _strip_generics(_node_text(type_node)),
+            }
+        )
+    return out
+
+
+def _strip_generics(t: str) -> str:
+    """``Box<String, Integer>`` → ``Box``; arrays / primitives untouched."""
+    t = t.strip()
+    if "<" in t:
+        return t.split("<", 1)[0].rstrip()
+    return t
+
+
+# ---------------------------------------------------------------------------
+# Annotation extraction (Plan 3 Task 1)
+# ---------------------------------------------------------------------------
+
+
+def _parse_annotations(decl_node: tree_sitter.Node) -> list[Annotation]:
+    """Walk a class/method/constructor declaration's ``modifiers`` child and
+    return every ``annotation`` / ``marker_annotation`` it carries as an
+    :class:`Annotation`."""
+    out: list[Annotation] = []
+    for child in decl_node.children:
+        if child.type != "modifiers":
+            continue
+        for m in child.children:
+            if m.type == "marker_annotation":
+                name = _annotation_name(m)
+                if name:
+                    out.append(Annotation(name=name, arguments={}))
+            elif m.type == "annotation":
+                name = _annotation_name(m)
+                args = _annotation_arguments(m)
+                if name:
+                    out.append(Annotation(name=name, arguments=args))
+    return out
+
+
+def _annotation_name(ann_node: tree_sitter.Node) -> str:
+    for child in ann_node.children:
+        if child.type in {"identifier", "scoped_identifier"}:
+            return _node_text(child)
+    return ""
+
+
+def _annotation_arguments(ann_node: tree_sitter.Node) -> dict[str, str]:
+    """``@RequestMapping("/x")`` → ``{"value": "/x"}``;
+    ``@X(name="a", v=1)`` → ``{"name": "a", "v": "1"}``;
+    ``@Override`` → ``{}``."""
+    args: dict[str, str] = {}
+    arglist = None
+    for child in ann_node.children:
+        if child.type == "annotation_argument_list":
+            arglist = child
+            break
+    if arglist is None:
+        return args
+    for child in arglist.children:
+        if child.type == "string_literal":
+            args["value"] = _strip_string_literal(_node_text(child))
+        elif child.type == "element_value_pair":
+            key_node = child.child_by_field_name("key")
+            val_node = child.child_by_field_name("value")
+            if key_node is None or val_node is None:
+                # fall back: first two non-`=` children
+                kids = [c for c in child.children if c.type not in {"="}]
+                if len(kids) < 2:
+                    continue
+                key_node, val_node = kids[0], kids[1]
+            key = _node_text(key_node)
+            value = _strip_string_literal(_node_text(val_node))
+            if key:
+                args[key] = value
+        elif child.type not in {"(", ")", ","} and "value" not in args:
+            # bare non-string single value (e.g. enum member, integer)
+            args["value"] = _strip_string_literal(_node_text(child))
+    return args
+
+
+def _strip_string_literal(s: str) -> str:
+    if len(s) >= 2 and s[0] == s[-1] and s[0] in {'"', "'"}:
+        return s[1:-1]
+    return s
+
+
+# ---------------------------------------------------------------------------
+# Spring http_route metadata (Plan 3 Task 2)
+# ---------------------------------------------------------------------------
+
+_VERB_ANNO = {
+    "GetMapping": "GET",
+    "PostMapping": "POST",
+    "PutMapping": "PUT",
+    "DeleteMapping": "DELETE",
+    "PatchMapping": "PATCH",
+}
+
+
+def _http_route_meta(
+    class_annos: list[Annotation],
+    method_annos: list[Annotation],
+) -> dict[str, str] | None:
+    """Combine class-level ``@RequestMapping`` prefix with the method's verb
+    mapping annotation. Returns ``{"method", "path"}`` or ``None`` when the
+    method has no mapping annotation."""
+    prefix = ""
+    for a in class_annos:
+        if a.name == "RequestMapping":
+            prefix = a.arguments.get("value", a.arguments.get("path", ""))
+            break
+
+    verb: str | None = None
+    path = ""
+    for a in method_annos:
+        if a.name in _VERB_ANNO:
+            verb = _VERB_ANNO[a.name]
+            path = a.arguments.get("value", a.arguments.get("path", ""))
+            break
+
+    if verb is None:
+        for a in method_annos:
+            if a.name == "RequestMapping":
+                verb = "GET"
+                path = a.arguments.get("value", a.arguments.get("path", ""))
+                break
+
+    if verb is None:
+        return None
+    return {"method": verb, "path": _join_route(prefix, path)}
+
+
+def _join_route(prefix: str, path: str) -> str:
+    parts = [seg for seg in (prefix + "/" + path).split("/") if seg]
+    return "/" + "/".join(parts) if parts else "/"

codemap_java/resolver.py

@@ -0,0 +1,285 @@
+"""JavaCallResolverBridge — cross-file FQN-based call/extends/implements resolver.
+
+Consumes the metadata that :class:`codemap_java.indexer.JavaIndexer` attaches
+to ``Symbol.extra``:
+
+* top-level class symbols carry ``package`` / ``imports`` / ``supertypes``
+* method symbols carry ``params`` (list of ``{name, type}``) and
+  ``pending_calls`` (raw invocation records — receiver text, method name,
+  argument arity, location)
+* field symbols carry ``type``
+
+Algorithm (single bridge pass, ADR-0013):
+
+1. Build a project-wide FQN table from all top-level Java classes
+   (``package + simple_name``).
+2. Index each class's methods (by name → list of (arity, sid)) and fields
+   (by name → type string), so we can dispatch later by arity and follow
+   field receivers to their declared types.
+3. Resolve each class's ``supertypes`` against ``imports`` + same-package
+   + java.lang implicit imports, emit ``extends`` / ``implements`` edges.
+4. For each pending invocation, infer the receiver class's FQN
+   (``""``/``"this"``/``"super"`` → caller class; capitalised → resolve as
+   type; lowercase → look up caller's field of that name and take its
+   declared type), then emit a ``calls`` edge iff exactly one method on
+   the target class matches by name + arity. Ambiguous / unresolved
+   invocations silently drop — they aren't crashes.
+
+All edges are emitted with ``confidence="medium"`` per ADR-0013's accepted
+trade-off versus full semantic resolution.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import PurePosixPath
+from typing import Any, ClassVar
+
+from codemap.core.models import BridgeResult, Edge
+from codemap.core.store import ReadOnlyStore
+from codemap.core.symbol import DescriptorKind, SymbolID
+
+__all__ = ["JavaCallResolverBridge"]
+
+
+class JavaCallResolverBridge:
+    name: ClassVar[str] = "java_calls"
+    version: ClassVar[str] = "0.1.0"
+    requires: ClassVar[list[str]] = []
+
+    def resolve(self, store: ReadOnlyStore) -> BridgeResult:
+        # One pass over the store to bucket java symbols.
+        classes: list[Any] = []
+        methods: list[Any] = []
+        fields: list[Any] = []
+        for sym in store.iter_symbols():
+            if sym.language != "java":
+                continue
+            if sym.kind == "class" and "imports" in sym.extra:
+                # Top-level only. (Nested classes don't carry imports; the
+                # current resolver doesn't follow them — see ADR-0013.)
+                classes.append(sym)
+            elif sym.kind == "method":
+                methods.append(sym)
+            elif sym.kind == "field":
+                fields.append(sym)
+
+        # Build FQN table + per-class info.
+        fqn_to_sid: dict[str, SymbolID] = {}
+        simple_to_fqn: dict[str, list[str]] = defaultdict(list)
+        info_by_sid: dict[SymbolID, _ClassInfo] = {}
+        file_to_classes: dict[PurePosixPath, list[_ClassInfo]] = defaultdict(list)
+
+        for cls in classes:
+            pkg = str(cls.extra.get("package", ""))
+            simple = cls.id.descriptors[-1].name
+            fqn = f"{pkg}.{simple}" if pkg else simple
+            fqn_to_sid[fqn] = cls.id
+            simple_to_fqn[simple].append(fqn)
+            info = _ClassInfo(
+                sid=cls.id,
+                fqn=fqn,
+                pkg=pkg,
+                simple_name=simple,
+                file=cls.file,
+                imports=list(cls.extra.get("imports", [])),
+                supertypes=list(cls.extra.get("supertypes", [])),
+            )
+            info_by_sid[cls.id] = info
+            file_to_classes[cls.file].append(info)
+
+        # Attach methods + fields to their owner class.
+        for m in methods:
+            owner = _owner_class(m, file_to_classes)
+            if owner is None:
+                continue
+            arity = len(m.extra.get("params", []))
+            owner.methods[m.id.descriptors[-1].name].append(
+                _MethodRecord(
+                    sid=m.id,
+                    arity=arity,
+                    pending_calls=list(m.extra.get("pending_calls", [])),
+                )
+            )
+        for f in fields:
+            owner = _owner_class(f, file_to_classes)
+            if owner is None:
+                continue
+            ftype = str(f.extra.get("type", "")).strip()
+            if ftype:
+                owner.fields[f.id.descriptors[-1].name] = ftype
+
+        # Resolver helpers in closure.
+        def resolve_type(name: str, ctx: _ClassInfo) -> str | None:
+            if "." in name:
+                return name if name in fqn_to_sid else None
+            same_pkg = f"{ctx.pkg}.{name}" if ctx.pkg else name
+            if same_pkg in fqn_to_sid:
+                return same_pkg
+            for imp in ctx.imports:
+                if imp.endswith(".*"):
+                    candidate = f"{imp[:-2]}.{name}"
+                    if candidate in fqn_to_sid:
+                        return candidate
+                elif imp.rsplit(".", 1)[-1] == name and imp in fqn_to_sid:
+                    return imp
+            # java.lang implicit
+            implicit = f"java.lang.{name}"
+            if implicit in fqn_to_sid:
+                return implicit
+            # Last resort: unique simple-name match across the project.
+            candidates = simple_to_fqn.get(name, [])
+            if len(candidates) == 1:
+                return candidates[0]
+            return None
+
+        edges: list[Edge] = []
+
+        # extends / implements edges.
+        for info in info_by_sid.values():
+            for sup in info.supertypes:
+                tgt_fqn = resolve_type(sup["name"], info)
+                if tgt_fqn is None:
+                    continue
+                edges.append(
+                    Edge(
+                        source=info.sid,
+                        target=fqn_to_sid[tgt_fqn],
+                        kind=sup["relation"],  # "extends" | "implements"
+                        confidence="medium",
+                    )
+                )
+
+        # calls edges.
+        for info in info_by_sid.values():
+            for records in info.methods.values():
+                for rec in records:
+                    for call in rec.pending_calls:
+                        tgt_sid = _resolve_call(call, info, resolve_type, fqn_to_sid, info_by_sid)
+                        if tgt_sid is None:
+                            continue
+                        edges.append(
+                            Edge(
+                                source=rec.sid,
+                                target=tgt_sid,
+                                kind="calls",
+                                confidence="medium",
+                            )
+                        )
+
+        return BridgeResult(edges=edges)
+
+
+# ---------------------------------------------------------------------------
+# Internal types
+# ---------------------------------------------------------------------------
+
+
+class _ClassInfo:
+    __slots__ = (
+        "fields",
+        "file",
+        "fqn",
+        "imports",
+        "methods",
+        "pkg",
+        "sid",
+        "simple_name",
+        "supertypes",
+    )
+
+    def __init__(
+        self,
+        *,
+        sid: SymbolID,
+        fqn: str,
+        pkg: str,
+        simple_name: str,
+        file: PurePosixPath,
+        imports: list[str],
+        supertypes: list[dict[str, str]],
+    ) -> None:
+        self.sid = sid
+        self.fqn = fqn
+        self.pkg = pkg
+        self.simple_name = simple_name
+        self.file = file
+        self.imports = imports
+        self.supertypes = supertypes
+        self.methods: dict[str, list[_MethodRecord]] = defaultdict(list)
+        self.fields: dict[str, str] = {}
+
+
+class _MethodRecord:
+    __slots__ = ("arity", "pending_calls", "sid")
+
+    def __init__(
+        self,
+        *,
+        sid: SymbolID,
+        arity: int,
+        pending_calls: list[dict[str, Any]],
+    ) -> None:
+        self.sid = sid
+        self.arity = arity
+        self.pending_calls = pending_calls
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _owner_class(
+    sym: Any,
+    file_to_classes: dict[PurePosixPath, list[_ClassInfo]],
+) -> _ClassInfo | None:
+    """Locate the top-level class that owns ``sym`` (a method or field).
+
+    Owner is the class whose simple name matches the second-to-last
+    descriptor of ``sym.id`` and lives in the same file.
+    """
+    descs = sym.id.descriptors
+    if len(descs) < 2 or descs[-2].kind is not DescriptorKind.TYPE:
+        return None
+    owner_name = descs[-2].name
+    for info in file_to_classes.get(sym.file, []):
+        if info.simple_name == owner_name:
+            return info
+    return None
+
+
+def _resolve_call(
+    call: dict[str, Any],
+    caller: _ClassInfo,
+    resolve_type,  # type: ignore[no-untyped-def]
+    fqn_to_sid: dict[str, SymbolID],
+    info_by_sid: dict[SymbolID, _ClassInfo],
+) -> SymbolID | None:
+    receiver = str(call.get("receiver", ""))
+    name = str(call.get("name", ""))
+    arity = int(call.get("arity", 0))
+    if not name:
+        return None
+
+    if receiver in {"", "this", "super"}:
+        target_fqn: str | None = caller.fqn
+    elif receiver and receiver[0].isupper():
+        target_fqn = resolve_type(receiver, caller)
+    else:
+        ftype = caller.fields.get(receiver)
+        target_fqn = resolve_type(ftype, caller) if ftype else None
+
+    if target_fqn is None:
+        return None
+    target_cls_sid = fqn_to_sid.get(target_fqn)
+    if target_cls_sid is None:
+        return None
+    target_info = info_by_sid.get(target_cls_sid)
+    if target_info is None:
+        return None
+
+    candidates = [m.sid for m in target_info.methods.get(name, []) if m.arity == arity]
+    if len(candidates) == 1:
+        return candidates[0]
+    return None

{codemap_java-0.2.0.dist-info → codemap_java-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codemap-java
-Version: 0.2.0
+Version: 0.3.0
 Summary: Java indexer plugin for CodeMap
 Project-URL: Homepage, https://github.com/qxbyte/codemap
 Author: CodeMap Contributors
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Java
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development
 Requires-Python: >=3.11
-Requires-Dist: codemap-core<0.3,>=0.2.0
+Requires-Dist: codemap-core<0.4,>=0.3.0
 Requires-Dist: tree-sitter-java>=0.23
 Requires-Dist: tree-sitter>=0.25
 Provides-Extra: dev

codemap_java-0.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+codemap_java/__init__.py,sha256=CfrzKPuFCV4SA9ly2O8K84G96OIBVTCWrDUFafKIOgY,170
+codemap_java/indexer.py,sha256=BLhd-j8P3Y3YbXhbss8CFyzA9heBjgtiYaBAkMo2EOw,21415
+codemap_java/resolver.py,sha256=niktAfVmautbbV6nVAWkLGzz2dtu6GYEzhFuWaQyJYA,9897
+codemap_java-0.3.0.dist-info/METADATA,sha256=RfUsDQh4-S2x8WcBHGw-HCcmXTaM9oaZYJ8bF86BEhw,2250
+codemap_java-0.3.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+codemap_java-0.3.0.dist-info/entry_points.txt,sha256=ffms-JC_vd26AXl4105KAWYteM0J1a5xw7hMqyIrWBo,128
+codemap_java-0.3.0.dist-info/RECORD,,

codemap_java-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[codemap.bridges]
+java_calls = codemap_java.resolver:JavaCallResolverBridge
+
+[codemap.indexers]
+java = codemap_java:JavaIndexer

codemap_java-0.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-codemap_java/__init__.py,sha256=CfrzKPuFCV4SA9ly2O8K84G96OIBVTCWrDUFafKIOgY,170
-codemap_java/indexer.py,sha256=exyqk2mvj-BAEli9Fi9beUcQIPu_MTXoL9h_QqLjGX0,8461
-codemap_java-0.2.0.dist-info/METADATA,sha256=7r9Lbl65HmdoeiOgPJZVGvQAoKSGWJTSrvkqO7oz0AQ,2250
-codemap_java-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-codemap_java-0.2.0.dist-info/entry_points.txt,sha256=nc_YzUZs5Nwz3H_qPVY1k1n4A1VtpA8F6Tj0AE6XnNc,51
-codemap_java-0.2.0.dist-info/RECORD,,

codemap_java-0.2.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[codemap.indexers]
-java = codemap_java:JavaIndexer