java-functional-lsp 0.9.3__tar.gz → 0.9.6__tar.gz

{java_functional_lsp-0.9.3 → java_functional_lsp-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.3
+Version: 0.9.6
 Summary: Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions
 Project-URL: Homepage, https://github.com/aviadshiber/java-functional-lsp
 Project-URL: Repository, https://github.com/aviadshiber/java-functional-lsp

{java_functional_lsp-0.9.3 → java_functional_lsp-0.9.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.3"
+version = "0.9.6"
 description = "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions"
 readme = "README.md"
 license = { text = "MIT" }

{java_functional_lsp-0.9.3 → java_functional_lsp-0.9.6}/src/java_functional_lsp/__init__.py

@@ -1,3 +1,3 @@
 """java-functional-lsp: A Java LSP server enforcing functional programming best practices."""
 
-__version__ = "0.9.3"
+__version__ = "0.9.6"

{java_functional_lsp-0.9.3 → java_functional_lsp-0.9.6}/src/java_functional_lsp/proxy.py

@@ -448,12 +448,12 @@ def _version_key(name: str) -> tuple[int, ...]:
 def _find_maven_group_root(initial_module: Path, workspace_root: Path) -> Path:
     """Return the tightest Maven multi-module parent of *initial_module*.
 
-    Walks up from ``initial_module.parent`` (the module itself is skipped —
-    we want its *parent* group, not the module's own pom) toward (and
-    including) ``workspace_root``, returning the first ancestor whose
-    ``pom.xml`` contains a ``<modules>`` section.  Falls back to
-    ``workspace_root`` when no such intermediate parent exists (e.g. flat
-    single-level monorepos).
+    Walks up from ``initial_module.parent`` toward (but NOT including)
+    ``workspace_root``, returning the first ancestor whose ``pom.xml``
+    contains a ``<modules>`` section.  Falls back to ``initial_module``
+    itself when no intermediate group pom exists (e.g. modules that sit
+    directly under ``workspace_root``), keeping the scope as tight as
+    possible and avoiding accidental full-monorepo indexing.
 
     This keeps the jdtls index bounded to a module *group* (typically
     5-20 modules) rather than the full IDE workspace (potentially 200+ modules)
@@ -463,11 +463,17 @@ def _find_maven_group_root(initial_module: Path, workspace_root: Path) -> Path:
     before walking to avoid symlink-based boundary escapes.
     """
     workspace_root = workspace_root.resolve()
-    current = initial_module.resolve().parent
-    # Bail immediately if the initial module is outside the workspace.
+    resolved_module = initial_module.resolve()
+    current = resolved_module.parent
+    # Case 1: module is outside the workspace entirely — scope to workspace_root
+    # (also fires when initial_module == workspace_root, since parent is then
+    # outside workspace_root).
     if not current.is_relative_to(workspace_root):
         return workspace_root
-    while True:
+    # Walk up to (but NOT including) workspace_root.  Inspecting workspace_root's
+    # own pom.xml would include the entire monorepo (e.g. 200+ modules) → OOM.
+    # `current.parent == current` detects the filesystem root (POSIX `/` or Windows drive).
+    while current not in (workspace_root, current.parent):
         pom = current / "pom.xml"
         if pom.is_file():
             try:
@@ -475,10 +481,10 @@ def _find_maven_group_root(initial_module: Path, workspace_root: Path) -> Path:
                     return current
             except OSError:
                 pass
-        if current in (workspace_root, current.parent):
-            break
         current = current.parent
-    return workspace_root
+    # Case 2: no intermediate group pom found — use the initial module as its own scope
+    # (tightest possible; avoids full-monorepo indexing for flat modules under workspace_root).
+    return resolved_module
 
 
 @lru_cache(maxsize=256)
@@ -924,8 +930,10 @@ class JdtlsProxy:
         Maven parent.  This covers sibling modules (the common case for
         cross-module navigation) without ballooning the index.
 
-        Falls back to the full IDE workspace root when no intermediate
-        multi-module parent is found.
+        Falls back to the initial module itself when no intermediate
+        multi-module parent is found (e.g. flat modules sitting directly
+        under the workspace root), keeping the jdtls scope as tight as
+        possible.
 
         Removes all individually-added module folders to avoid double-indexing
         with the newly added group root.

{java_functional_lsp-0.9.3 → java_functional_lsp-0.9.6}/src/java_functional_lsp/server.py

@@ -446,6 +446,20 @@ _JDTLS_CAPABILITIES: list[tuple[str, str, type[Any], dict[str, Any]]] = [
     ("definition", lsp.TEXT_DOCUMENT_DEFINITION, lsp.DefinitionRegistrationOptions, {}),
     ("references", lsp.TEXT_DOCUMENT_REFERENCES, lsp.ReferenceRegistrationOptions, {}),
     ("document-symbol", lsp.TEXT_DOCUMENT_DOCUMENT_SYMBOL, lsp.DocumentSymbolRegistrationOptions, {}),
+    ("call-hierarchy", lsp.TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY, lsp.CallHierarchyRegistrationOptions, {}),
+    (
+        "signature-help",
+        lsp.TEXT_DOCUMENT_SIGNATURE_HELP,
+        lsp.SignatureHelpRegistrationOptions,
+        {"trigger_characters": ["(", ","], "retrigger_characters": [")"]},
+    ),
+    ("implementation", lsp.TEXT_DOCUMENT_IMPLEMENTATION, lsp.ImplementationRegistrationOptions, {}),
+    ("type-definition", lsp.TEXT_DOCUMENT_TYPE_DEFINITION, lsp.TypeDefinitionRegistrationOptions, {}),
+    ("declaration", lsp.TEXT_DOCUMENT_DECLARATION, lsp.DeclarationRegistrationOptions, {}),
+    ("document-highlight", lsp.TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT, lsp.DocumentHighlightRegistrationOptions, {}),
+    ("rename", lsp.TEXT_DOCUMENT_RENAME, lsp.RenameRegistrationOptions, {"prepare_provider": True}),
+    ("type-hierarchy", lsp.TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY, lsp.TypeHierarchyRegistrationOptions, {}),
+    ("workspace-symbol", lsp.WORKSPACE_SYMBOL, lsp.WorkspaceSymbolRegistrationOptions, {}),
 ]
 
 # Maps LSP method → handler function for dynamic registration.
@@ -457,14 +471,20 @@ _jdtls_capabilities_registered = False
 
 def _build_jdtls_registrations() -> list[lsp.Registration]:
     """Build LSP Registration objects for jdtls-dependent capabilities."""
-    return [
-        lsp.Registration(
-            id=f"{_JDTLS_REG_PREFIX}{suffix}",
-            method=method,
-            register_options=_converter.unstructure(opts_cls(document_selector=_JAVA_SELECTOR, **extra)),
+    result = []
+    for suffix, method, opts_cls, extra in _JDTLS_CAPABILITIES:
+        field_names = {f.name for f in getattr(opts_cls, "__attrs_attrs__", [])}
+        kwargs: dict[str, Any] = {**extra}
+        if "document_selector" in field_names:
+            kwargs["document_selector"] = _JAVA_SELECTOR
+        result.append(
+            lsp.Registration(
+                id=f"{_JDTLS_REG_PREFIX}{suffix}",
+                method=method,
+                register_options=_converter.unstructure(opts_cls(**kwargs)),
+            )
         )
-        for suffix, method, opts_cls, extra in _JDTLS_CAPABILITIES
-    ]
+    return result
 
 
 async def _register_jdtls_capabilities() -> None:
@@ -499,7 +519,11 @@ async def _register_jdtls_capabilities() -> None:
             return
 
         _jdtls_capabilities_registered = True
-        logger.info("Dynamically registered jdtls capabilities (hover, definition, references, completion, symbol)")
+        logger.info(
+            "jdtls capabilities registered: completion, hover, definition, references, symbol, "
+            "call-hierarchy, signature-help, implementation, type-definition, declaration, "
+            "document-highlight, rename, type-hierarchy, workspace-symbol"
+        )
     except Exception:
         logger.warning("Failed to dynamically register jdtls capabilities", exc_info=True)
 
@@ -739,6 +763,198 @@ async def _on_document_symbol(params: lsp.DocumentSymbolParams) -> list[lsp.Docu
         return None
 
 
+async def _on_prepare_call_hierarchy(params: lsp.CallHierarchyPrepareParams) -> list[lsp.CallHierarchyItem] | None:
+    """Forward prepareCallHierarchy request to jdtls."""
+    result = await _ensure_module_and_forward("textDocument/prepareCallHierarchy", params, params.text_document.uri)
+    if result is None:
+        return None
+    try:
+        return [_converter.structure(item, lsp.CallHierarchyItem) for item in result]
+    except Exception:
+        return None
+
+
+async def _on_incoming_calls(
+    params: lsp.CallHierarchyIncomingCallsParams,
+) -> list[lsp.CallHierarchyIncomingCall] | None:
+    """Forward callHierarchy/incomingCalls request to jdtls."""
+    result = await _ensure_module_and_forward("callHierarchy/incomingCalls", params, params.item.uri)
+    if result is None:
+        return None
+    try:
+        return [_converter.structure(c, lsp.CallHierarchyIncomingCall) for c in result]
+    except Exception:
+        return None
+
+
+async def _on_outgoing_calls(
+    params: lsp.CallHierarchyOutgoingCallsParams,
+) -> list[lsp.CallHierarchyOutgoingCall] | None:
+    """Forward callHierarchy/outgoingCalls request to jdtls."""
+    result = await _ensure_module_and_forward("callHierarchy/outgoingCalls", params, params.item.uri)
+    if result is None:
+        return None
+    try:
+        return [_converter.structure(c, lsp.CallHierarchyOutgoingCall) for c in result]
+    except Exception:
+        return None
+
+
+async def _on_signature_help(params: lsp.SignatureHelpParams) -> lsp.SignatureHelp | None:
+    """Forward signatureHelp request to jdtls."""
+    result = await _ensure_module_and_forward("textDocument/signatureHelp", params, params.text_document.uri)
+    if result is None:
+        return None
+    try:
+        return _converter.structure(result, lsp.SignatureHelp)
+    except Exception:
+        logger.debug("Failed to structure signatureHelp result", exc_info=True)
+        return None
+
+
+async def _on_implementation(params: lsp.ImplementationParams) -> list[lsp.Location] | None:
+    """Forward go-to-implementation request to jdtls."""
+    result = await _ensure_module_and_forward("textDocument/implementation", params, params.text_document.uri)
+    if result is None:
+        return None
+    try:
+        if isinstance(result, list):
+            return [_converter.structure(loc, lsp.Location) for loc in result]
+        return [_converter.structure(result, lsp.Location)]
+    except Exception:
+        logger.debug("Failed to structure implementation result", exc_info=True)
+        return None
+
+
+async def _on_type_definition(params: lsp.TypeDefinitionParams) -> list[lsp.Location] | None:
+    """Forward go-to-type-definition request to jdtls."""
+    result = await _ensure_module_and_forward("textDocument/typeDefinition", params, params.text_document.uri)
+    if result is None:
+        return None
+    try:
+        if isinstance(result, list):
+            return [_converter.structure(loc, lsp.Location) for loc in result]
+        return [_converter.structure(result, lsp.Location)]
+    except Exception:
+        logger.debug("Failed to structure typeDefinition result", exc_info=True)
+        return None
+
+
+async def _on_declaration(params: lsp.DeclarationParams) -> list[lsp.Location] | None:
+    """Forward go-to-declaration request to jdtls."""
+    result = await _ensure_module_and_forward("textDocument/declaration", params, params.text_document.uri)
+    if result is None:
+        return None
+    try:
+        if isinstance(result, list):
+            return [_converter.structure(loc, lsp.Location) for loc in result]
+        return [_converter.structure(result, lsp.Location)]
+    except Exception:
+        logger.debug("Failed to structure declaration result", exc_info=True)
+        return None
+
+
+async def _on_document_highlight(params: lsp.DocumentHighlightParams) -> list[lsp.DocumentHighlight] | None:
+    """Forward documentHighlight request to jdtls."""
+    result = await _ensure_module_and_forward("textDocument/documentHighlight", params, params.text_document.uri)
+    if result is None:
+        return None
+    try:
+        return [_converter.structure(h, lsp.DocumentHighlight) for h in result]
+    except Exception:
+        logger.debug("Failed to structure documentHighlight result", exc_info=True)
+        return None
+
+
+async def _on_rename(params: lsp.RenameParams) -> lsp.WorkspaceEdit | None:
+    """Forward rename request to jdtls."""
+    result = await _ensure_module_and_forward("textDocument/rename", params, params.text_document.uri)
+    if result is None:
+        return None
+    try:
+        return _converter.structure(result, lsp.WorkspaceEdit)
+    except Exception:
+        logger.debug("Failed to structure rename result", exc_info=True)
+        return None
+
+
+async def _on_prepare_rename(
+    params: lsp.PrepareRenameParams,
+) -> lsp.Range | lsp.PrepareRenamePlaceholder | lsp.PrepareRenameDefaultBehavior | None:
+    """Forward prepareRename request to jdtls.
+
+    jdtls may return Range, PrepareRenamePlaceholder ({range, placeholder}),
+    or PrepareRenameDefaultBehavior ({defaultBehavior}) — try each in order.
+    """
+    result = await _ensure_module_and_forward("textDocument/prepareRename", params, params.text_document.uri)
+    if result is None:
+        return None
+    for target_type in (lsp.PrepareRenamePlaceholder, lsp.PrepareRenameDefaultBehavior, lsp.Range):
+        try:
+            return _converter.structure(result, target_type)  # type: ignore[return-value]
+        except Exception:
+            pass
+    logger.debug("Failed to structure prepareRename result as any known type", exc_info=False)
+    return None
+
+
+async def _on_prepare_type_hierarchy(
+    params: lsp.TypeHierarchyPrepareParams,
+) -> list[lsp.TypeHierarchyItem] | None:
+    """Forward prepareTypeHierarchy request to jdtls."""
+    result = await _ensure_module_and_forward("textDocument/prepareTypeHierarchy", params, params.text_document.uri)
+    if result is None:
+        return None
+    try:
+        return [_converter.structure(item, lsp.TypeHierarchyItem) for item in result]
+    except Exception:
+        logger.debug("Failed to structure prepareTypeHierarchy result", exc_info=True)
+        return None
+
+
+async def _on_type_hierarchy_supertypes(
+    params: lsp.TypeHierarchySupertypesParams,
+) -> list[lsp.TypeHierarchyItem] | None:
+    """Forward typeHierarchy/supertypes request to jdtls."""
+    result = await _ensure_module_and_forward("typeHierarchy/supertypes", params, params.item.uri)
+    if result is None:
+        return None
+    try:
+        return [_converter.structure(item, lsp.TypeHierarchyItem) for item in result]
+    except Exception:
+        logger.debug("Failed to structure typeHierarchy/supertypes result", exc_info=True)
+        return None
+
+
+async def _on_type_hierarchy_subtypes(
+    params: lsp.TypeHierarchySubtypesParams,
+) -> list[lsp.TypeHierarchyItem] | None:
+    """Forward typeHierarchy/subtypes request to jdtls."""
+    result = await _ensure_module_and_forward("typeHierarchy/subtypes", params, params.item.uri)
+    if result is None:
+        return None
+    try:
+        return [_converter.structure(item, lsp.TypeHierarchyItem) for item in result]
+    except Exception:
+        logger.debug("Failed to structure typeHierarchy/subtypes result", exc_info=True)
+        return None
+
+
+async def _on_workspace_symbol(params: lsp.WorkspaceSymbolParams) -> list[lsp.WorkspaceSymbol] | None:
+    """Forward workspace/symbol request to jdtls (no text_document — use proxy directly)."""
+    proxy = server._proxy
+    if not proxy.is_available:
+        return None
+    result = await proxy.send_request("workspace/symbol", _serialize_params(params))
+    if result is None:
+        return None
+    try:
+        return [_converter.structure(s, lsp.WorkspaceSymbol) for s in result]
+    except Exception:
+        logger.debug("Failed to structure workspace/symbol result", exc_info=True)
+        return None
+
+
 # Populate handler map for dynamic registration.
 _JDTLS_HANDLERS.update(
     {
@@ -747,6 +963,20 @@ _JDTLS_HANDLERS.update(
         lsp.TEXT_DOCUMENT_DEFINITION: _on_definition,
         lsp.TEXT_DOCUMENT_REFERENCES: _on_references,
         lsp.TEXT_DOCUMENT_DOCUMENT_SYMBOL: _on_document_symbol,
+        lsp.TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY: _on_prepare_call_hierarchy,
+        lsp.CALL_HIERARCHY_INCOMING_CALLS: _on_incoming_calls,
+        lsp.CALL_HIERARCHY_OUTGOING_CALLS: _on_outgoing_calls,
+        lsp.TEXT_DOCUMENT_SIGNATURE_HELP: _on_signature_help,
+        lsp.TEXT_DOCUMENT_IMPLEMENTATION: _on_implementation,
+        lsp.TEXT_DOCUMENT_TYPE_DEFINITION: _on_type_definition,
+        lsp.TEXT_DOCUMENT_DECLARATION: _on_declaration,
+        lsp.TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT: _on_document_highlight,
+        lsp.TEXT_DOCUMENT_RENAME: _on_rename,
+        lsp.TEXT_DOCUMENT_PREPARE_RENAME: _on_prepare_rename,
+        lsp.TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY: _on_prepare_type_hierarchy,
+        lsp.TYPE_HIERARCHY_SUPERTYPES: _on_type_hierarchy_supertypes,
+        lsp.TYPE_HIERARCHY_SUBTYPES: _on_type_hierarchy_subtypes,
+        lsp.WORKSPACE_SYMBOL: _on_workspace_symbol,
     }
 )
 

{java_functional_lsp-0.9.3 → java_functional_lsp-0.9.6}/tests/test_proxy.py

@@ -1131,17 +1131,24 @@ class TestLazyStart:
         assert event["added"][0]["uri"] == group.as_uri()
         assert event["added"][0]["uri"] != workspace_uri
 
-    async def test_expand_falls_back_to_workspace_root_when_no_group_pom(self, tmp_path: Path) -> None:
-        """Falls back to the IDE workspace root when no intermediate multi-module parent exists."""
+    async def test_expand_noop_for_flat_module_directly_under_workspace(self, tmp_path: Path) -> None:
+        """No notification sent for flat modules sitting directly under workspace_root.
+
+        When there is no intermediate group pom between the module and workspace_root,
+        _find_maven_group_root returns the module itself (not workspace_root). Since the
+        module was already added, expand_full_workspace() is a no-op — which is correct:
+        the scope is already as tight as possible and workspace_root's pom.xml
+        (potentially 200+ modules → OOM) is never inspected.
+        """
         from unittest.mock import AsyncMock
 
         from java_functional_lsp.proxy import JdtlsProxy
 
-        # Flat layout: workspace/module — no intermediate pom.xml
+        # Flat layout: workspace/module — no intermediate pom.xml between module and workspace
         workspace = tmp_path / "workspace"
         module = workspace / "module"
         module.mkdir(parents=True)
-        # workspace/pom.xml has <modules>, but there's nothing in between
+        # workspace/pom.xml has <modules>, but the walk stops BEFORE reaching it
         (workspace / "pom.xml").write_text("<project><modules><module>module</module></modules></project>")
 
         module_uri = module.as_uri()
@@ -1155,9 +1162,9 @@ class TestLazyStart:
         proxy.send_notification = AsyncMock()  # type: ignore[assignment]
         await proxy.expand_full_workspace()
 
-        call_args = proxy.send_notification.call_args[0]  # type: ignore[attr-defined]
-        event = call_args[1]["event"]
-        assert event["added"][0]["uri"] == workspace_uri
+        # No notification — module was already added and is already the tightest scope
+        proxy.send_notification.assert_not_called()  # type: ignore[attr-defined]
+        assert proxy._workspace_expanded is True
 
     async def test_expand_full_workspace_sends_notification(self) -> None:
         from unittest.mock import AsyncMock
@@ -1172,28 +1179,43 @@ class TestLazyStart:
         proxy.send_notification.assert_called_once()  # type: ignore[attr-defined]
         assert proxy._workspace_expanded is True
 
-    async def test_expand_full_workspace_removes_initial_module(self) -> None:
-        """All modules in _states (not just _initial_module_uri) are removed on expansion."""
+    async def test_expand_full_workspace_removes_initial_module(self, tmp_path: Path) -> None:
+        """All modules in _states are removed when expanding to an intermediate group root."""
         from unittest.mock import AsyncMock
 
         from java_functional_lsp.proxy import JdtlsProxy
 
+        # Layout: monorepo/group/module-a, monorepo/group/module-b
+        # group/pom.xml has <modules> → group becomes the expansion target
+        monorepo = tmp_path / "monorepo"
+        group = monorepo / "group"
+        module_a = group / "module-a"
+        module_b = group / "module-b"
+        for d in (module_a, module_b):
+            d.mkdir(parents=True)
+        (group / "pom.xml").write_text("<project><modules><module>module-a</module></modules></project>")
+
+        module_a_uri = module_a.as_uri()
+        module_b_uri = module_b.as_uri()
+        monorepo_uri = monorepo.as_uri()
+        group_uri = group.as_uri()
+
         proxy = JdtlsProxy()
         proxy._available = True
-        proxy._original_root_uri = "file:///workspace/monorepo"
-        proxy._initial_module_uri = "file:///workspace/monorepo/module-a"
-        # Simulate that module-a was mark_added during start() and module-b via add_module_if_new
-        proxy.modules.mark_added("file:///workspace/monorepo/module-a")
-        proxy.modules.mark_added("file:///workspace/monorepo/module-b")
+        proxy._original_root_uri = monorepo_uri
+        proxy._initial_module_uri = module_a_uri
+        # Simulate module-a added during start() and module-b via add_module_if_new
+        proxy.modules.mark_added(module_a_uri)
+        proxy.modules.mark_added(module_b_uri)
         proxy.send_notification = AsyncMock()  # type: ignore[assignment]
         await proxy.expand_full_workspace()
         proxy.send_notification.assert_called_once()  # type: ignore[attr-defined]
         call_args = proxy.send_notification.call_args[0]  # type: ignore[attr-defined]
         event = call_args[1]["event"]
         removed_uris = {e["uri"] for e in event["removed"]}
-        assert "file:///workspace/monorepo/module-a" in removed_uris
-        assert "file:///workspace/monorepo/module-b" in removed_uris
-        assert event["added"][0]["uri"] == "file:///workspace/monorepo"
+        assert module_a_uri in removed_uris
+        assert module_b_uri in removed_uris
+        assert event["added"][0]["uri"] == group_uri
 
     async def test_expand_full_workspace_noop_when_not_available(self) -> None:
         from unittest.mock import AsyncMock