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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.4
+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.4 → java_functional_lsp-0.9.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.4"
+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.4 → 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.4"
+__version__ = "0.9.6"

{java_functional_lsp-0.9.4 → 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.4 → java_functional_lsp-0.9.6}/tests/test_server.py

@@ -319,25 +319,47 @@ class TestServerInternals:
         from java_functional_lsp.server import _JDTLS_REG_PREFIX, _build_jdtls_registrations
 
         regs = _build_jdtls_registrations()
-        assert len(regs) == 5
+        assert len(regs) == 14
         methods = {r.method for r in regs}
         assert lsp.TEXT_DOCUMENT_HOVER in methods
         assert lsp.TEXT_DOCUMENT_DEFINITION in methods
         assert lsp.TEXT_DOCUMENT_REFERENCES in methods
         assert lsp.TEXT_DOCUMENT_COMPLETION in methods
         assert lsp.TEXT_DOCUMENT_DOCUMENT_SYMBOL in methods
+        assert lsp.TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY in methods
+        assert lsp.TEXT_DOCUMENT_SIGNATURE_HELP in methods
+        assert lsp.TEXT_DOCUMENT_IMPLEMENTATION in methods
+        assert lsp.TEXT_DOCUMENT_TYPE_DEFINITION in methods
+        assert lsp.TEXT_DOCUMENT_DECLARATION in methods
+        assert lsp.TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT in methods
+        assert lsp.TEXT_DOCUMENT_RENAME in methods
+        assert lsp.TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY in methods
+        assert lsp.WORKSPACE_SYMBOL in methods
         # All IDs are unique and use the shared prefix
         ids = {r.id for r in regs}
-        assert len(ids) == 5
+        assert len(ids) == 14
         assert all(rid.startswith(_JDTLS_REG_PREFIX) for rid in ids)
-        # All have java document selector with correct language
+        # Document-scoped capabilities have java document selector; workspace-scoped do not
+        workspace_scoped = {lsp.WORKSPACE_SYMBOL}
         for r in regs:
             assert r.register_options is not None
-            selectors = r.register_options["documentSelector"]
-            assert any(s.get("language") == "java" for s in selectors)
+            if r.method in workspace_scoped:
+                assert "documentSelector" not in r.register_options
+            else:
+                selectors = r.register_options["documentSelector"]
+                assert any(s.get("language") == "java" for s in selectors)
         # Completion has triggerCharacters
         comp = next(r for r in regs if r.method == lsp.TEXT_DOCUMENT_COMPLETION)
+        assert comp.register_options is not None
         assert comp.register_options.get("triggerCharacters") == ["."]
+        # SignatureHelp has triggerCharacters
+        sig = next(r for r in regs if r.method == lsp.TEXT_DOCUMENT_SIGNATURE_HELP)
+        assert sig.register_options is not None
+        assert sig.register_options.get("triggerCharacters") == ["(", ","]
+        # Rename advertises prepareProvider so the IDE sends textDocument/prepareRename
+        rename = next(r for r in regs if r.method == lsp.TEXT_DOCUMENT_RENAME)
+        assert rename.register_options is not None
+        assert rename.register_options.get("prepareProvider") is True
 
     async def test_register_jdtls_capabilities_logs_on_failure(self, caplog: Any) -> None:
         """_register_jdtls_capabilities logs a warning when the client rejects."""
@@ -386,16 +408,30 @@ class TestServerInternals:
                 await srv_mod._register_jdtls_capabilities()
         finally:
             srv_mod._jdtls_capabilities_registered = old_flag
-        # Handlers were registered for all 5 methods
+        # Handlers were registered for all methods (including call hierarchy)
         assert lsp.TEXT_DOCUMENT_HOVER in registered_methods
         assert lsp.TEXT_DOCUMENT_COMPLETION in registered_methods
         assert lsp.TEXT_DOCUMENT_DEFINITION in registered_methods
         assert lsp.TEXT_DOCUMENT_REFERENCES in registered_methods
         assert lsp.TEXT_DOCUMENT_DOCUMENT_SYMBOL in registered_methods
+        assert lsp.TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY in registered_methods
+        assert lsp.CALL_HIERARCHY_INCOMING_CALLS in registered_methods
+        assert lsp.CALL_HIERARCHY_OUTGOING_CALLS in registered_methods
+        assert lsp.TEXT_DOCUMENT_SIGNATURE_HELP in registered_methods
+        assert lsp.TEXT_DOCUMENT_IMPLEMENTATION in registered_methods
+        assert lsp.TEXT_DOCUMENT_TYPE_DEFINITION in registered_methods
+        assert lsp.TEXT_DOCUMENT_DECLARATION in registered_methods
+        assert lsp.TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT in registered_methods
+        assert lsp.TEXT_DOCUMENT_RENAME in registered_methods
+        assert lsp.TEXT_DOCUMENT_PREPARE_RENAME in registered_methods
+        assert lsp.TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY in registered_methods
+        assert lsp.TYPE_HIERARCHY_SUPERTYPES in registered_methods
+        assert lsp.TYPE_HIERARCHY_SUBTYPES in registered_methods
+        assert lsp.WORKSPACE_SYMBOL in registered_methods
         # client_register_capability_async was called
         mock_reg.assert_called_once()
         # Success log emitted
-        assert any("Dynamically registered" in r.getMessage() for r in caplog.records)
+        assert any("jdtls capabilities registered" in r.getMessage() for r in caplog.records)
 
     async def test_register_jdtls_capabilities_idempotent(self) -> None:
         """Second call is a no-op (idempotency guard)."""
@@ -505,7 +541,7 @@ class TestServerInternals:
         mock_add = AsyncMock(return_value="file:///mod")
         mock_send = AsyncMock(side_effect=[None, {"result": "ok"}])
 
-        async def mock_wait(uri: str, timeout: float = 30.0) -> bool:
+        async def mock_wait(uri: str, timeout: float = 30.0) -> bool:  # pyright: ignore[reportUnusedParameter]
             srv._proxy.modules.mark_ready(uri)
             return True
 
@@ -545,6 +581,530 @@ class TestServerInternals:
         finally:
             srv._proxy.modules.clear()
 
+    async def test_on_prepare_call_hierarchy_forwards_to_jdtls(self) -> None:
+        """_on_prepare_call_hierarchy forwards request and structures result."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_prepare_call_hierarchy
+
+        item = {
+            "name": "parsePrimaryEnrichmentResponse",
+            "kind": 6,
+            "uri": "file:///mod/Foo.java",
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 10}},
+            "selectionRange": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 10}},
+        }
+        params = lsp.CallHierarchyPrepareParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        mock_forward = AsyncMock(return_value=[item])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_prepare_call_hierarchy(params)
+        assert result is not None
+        assert len(result) == 1
+        assert result[0].name == "parsePrimaryEnrichmentResponse"
+        mock_forward.assert_called_once_with("textDocument/prepareCallHierarchy", params, "file:///mod/Foo.java")
+
+    async def test_on_prepare_call_hierarchy_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_prepare_call_hierarchy
+
+        params = lsp.CallHierarchyPrepareParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            result = await _on_prepare_call_hierarchy(params)
+        assert result is None
+
+    async def test_on_incoming_calls_forwards_using_item_uri(self) -> None:
+        """_on_incoming_calls uses params.item.uri as the file_uri for module resolution."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_incoming_calls
+
+        item = lsp.CallHierarchyItem(
+            name="caller",
+            kind=lsp.SymbolKind.Method,
+            uri="file:///mod/Foo.java",
+            range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=5)),
+            selection_range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=5)),
+        )
+        params = lsp.CallHierarchyIncomingCallsParams(item=item)
+        incoming = {
+            "from": {
+                "name": "caller",
+                "kind": 6,
+                "uri": "file:///mod/Foo.java",
+                "range": {"start": {"line": 1, "character": 0}, "end": {"line": 1, "character": 6}},
+                "selectionRange": {"start": {"line": 1, "character": 0}, "end": {"line": 1, "character": 6}},
+            },
+            "fromRanges": [{"start": {"line": 1, "character": 0}, "end": {"line": 1, "character": 6}}],
+        }
+        mock_forward = AsyncMock(return_value=[incoming])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_incoming_calls(params)
+        assert result is not None
+        assert len(result) == 1
+        mock_forward.assert_called_once_with("callHierarchy/incomingCalls", params, "file:///mod/Foo.java")
+
+    async def test_on_incoming_calls_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_incoming_calls
+
+        item = lsp.CallHierarchyItem(
+            name="x",
+            kind=lsp.SymbolKind.Method,
+            uri="file:///mod/Foo.java",
+            range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=1)),
+            selection_range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=1)),
+        )
+        params = lsp.CallHierarchyIncomingCallsParams(item=item)
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            result = await _on_incoming_calls(params)
+        assert result is None
+
+    async def test_on_outgoing_calls_forwards_using_item_uri(self) -> None:
+        """_on_outgoing_calls uses params.item.uri as the file_uri for module resolution."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_outgoing_calls
+
+        item = lsp.CallHierarchyItem(
+            name="callee",
+            kind=lsp.SymbolKind.Method,
+            uri="file:///mod/Bar.java",
+            range=lsp.Range(start=lsp.Position(line=5, character=0), end=lsp.Position(line=5, character=6)),
+            selection_range=lsp.Range(start=lsp.Position(line=5, character=0), end=lsp.Position(line=5, character=6)),
+        )
+        params = lsp.CallHierarchyOutgoingCallsParams(item=item)
+        outgoing = {
+            "to": {
+                "name": "callee",
+                "kind": 6,
+                "uri": "file:///mod/Bar.java",
+                "range": {"start": {"line": 5, "character": 0}, "end": {"line": 5, "character": 6}},
+                "selectionRange": {"start": {"line": 5, "character": 0}, "end": {"line": 5, "character": 6}},
+            },
+            "fromRanges": [{"start": {"line": 5, "character": 0}, "end": {"line": 5, "character": 6}}],
+        }
+        mock_forward = AsyncMock(return_value=[outgoing])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_outgoing_calls(params)
+        assert result is not None
+        assert len(result) == 1
+        mock_forward.assert_called_once_with("callHierarchy/outgoingCalls", params, "file:///mod/Bar.java")
+
+    async def test_on_signature_help_forwards_to_jdtls(self) -> None:
+        """_on_signature_help forwards and structures a SignatureHelp result."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_signature_help
+
+        params = lsp.SignatureHelpParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=5, character=10),
+        )
+        raw = {"signatures": [{"label": "foo(int x)"}], "activeSignature": 0}
+        mock_forward = AsyncMock(return_value=raw)
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_signature_help(params)
+        assert result is not None
+        mock_forward.assert_called_once_with("textDocument/signatureHelp", params, "file:///mod/Foo.java")
+
+    async def test_on_signature_help_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_signature_help
+
+        params = lsp.SignatureHelpParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_signature_help(params) is None
+
+    async def test_on_implementation_forwards_using_text_document_uri(self) -> None:
+        """_on_implementation uses params.text_document.uri and handles list result."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_implementation
+
+        params = lsp.ImplementationParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        loc = {
+            "uri": "file:///mod/Impl.java",
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 5}},
+        }
+        mock_forward = AsyncMock(return_value=[loc])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_implementation(params)
+        assert result is not None
+        assert len(result) == 1
+        mock_forward.assert_called_once_with("textDocument/implementation", params, "file:///mod/Foo.java")
+
+    async def test_on_implementation_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_implementation
+
+        params = lsp.ImplementationParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_implementation(params) is None
+
+    async def test_on_document_highlight_forwards_to_jdtls(self) -> None:
+        """_on_document_highlight forwards and structures list result."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_document_highlight
+
+        params = lsp.DocumentHighlightParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        raw = [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 3}}}]
+        mock_forward = AsyncMock(return_value=raw)
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_document_highlight(params)
+        assert result is not None
+        assert len(result) == 1
+        mock_forward.assert_called_once_with("textDocument/documentHighlight", params, "file:///mod/Foo.java")
+
+    async def test_on_rename_forwards_and_returns_workspace_edit(self) -> None:
+        """_on_rename forwards and structures a WorkspaceEdit."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_rename
+
+        params = lsp.RenameParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+            new_name="Bar",
+        )
+        raw: dict[str, object] = {"changes": {}}
+        mock_forward = AsyncMock(return_value=raw)
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_rename(params)
+        assert result is not None
+        mock_forward.assert_called_once_with("textDocument/rename", params, "file:///mod/Foo.java")
+
+    async def test_on_rename_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_rename
+
+        params = lsp.RenameParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+            new_name="Bar",
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_rename(params) is None
+
+    async def test_on_prepare_type_hierarchy_forwards_to_jdtls(self) -> None:
+        """_on_prepare_type_hierarchy forwards and structures TypeHierarchyItem list."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_prepare_type_hierarchy
+
+        params = lsp.TypeHierarchyPrepareParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        item = {
+            "name": "Foo",
+            "kind": 5,
+            "uri": "file:///mod/Foo.java",
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 3}},
+            "selectionRange": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 3}},
+        }
+        mock_forward = AsyncMock(return_value=[item])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_prepare_type_hierarchy(params)
+        assert result is not None
+        assert len(result) == 1
+        assert result[0].name == "Foo"
+        mock_forward.assert_called_once_with("textDocument/prepareTypeHierarchy", params, "file:///mod/Foo.java")
+
+    async def test_on_type_hierarchy_supertypes_uses_item_uri(self) -> None:
+        """_on_type_hierarchy_supertypes uses params.item.uri for module resolution."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_type_hierarchy_supertypes
+
+        item = lsp.TypeHierarchyItem(
+            name="Foo",
+            kind=lsp.SymbolKind.Class,
+            uri="file:///mod/Foo.java",
+            range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=3)),
+            selection_range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=3)),
+        )
+        params = lsp.TypeHierarchySupertypesParams(item=item)
+        parent = {
+            "name": "Base",
+            "kind": 5,
+            "uri": "file:///mod/Base.java",
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 4}},
+            "selectionRange": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 4}},
+        }
+        mock_forward = AsyncMock(return_value=[parent])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_type_hierarchy_supertypes(params)
+        assert result is not None
+        assert len(result) == 1
+        assert result[0].name == "Base"
+        mock_forward.assert_called_once_with("typeHierarchy/supertypes", params, "file:///mod/Foo.java")
+
+    async def test_on_type_hierarchy_subtypes_uses_item_uri(self) -> None:
+        """_on_type_hierarchy_subtypes uses params.item.uri for module resolution."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_type_hierarchy_subtypes
+
+        item = lsp.TypeHierarchyItem(
+            name="Base",
+            kind=lsp.SymbolKind.Class,
+            uri="file:///mod/Base.java",
+            range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=4)),
+            selection_range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=4)),
+        )
+        params = lsp.TypeHierarchySubtypesParams(item=item)
+        child = {
+            "name": "Impl",
+            "kind": 5,
+            "uri": "file:///mod/Impl.java",
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 4}},
+            "selectionRange": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 4}},
+        }
+        mock_forward = AsyncMock(return_value=[child])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_type_hierarchy_subtypes(params)
+        assert result is not None
+        assert len(result) == 1
+        assert result[0].name == "Impl"
+        mock_forward.assert_called_once_with("typeHierarchy/subtypes", params, "file:///mod/Base.java")
+
+    async def test_on_type_definition_forwards_to_jdtls(self) -> None:
+        """_on_type_definition uses params.text_document.uri and handles list result."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_type_definition
+
+        params = lsp.TypeDefinitionParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        loc = {
+            "uri": "file:///mod/FooType.java",
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 7}},
+        }
+        mock_forward = AsyncMock(return_value=[loc])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_type_definition(params)
+        assert result is not None
+        assert len(result) == 1
+        mock_forward.assert_called_once_with("textDocument/typeDefinition", params, "file:///mod/Foo.java")
+
+    async def test_on_declaration_forwards_to_jdtls(self) -> None:
+        """_on_declaration uses params.text_document.uri and handles list result."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_declaration
+
+        params = lsp.DeclarationParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        loc = {
+            "uri": "file:///mod/IFoo.java",
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 4}},
+        }
+        mock_forward = AsyncMock(return_value=[loc])
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_declaration(params)
+        assert result is not None
+        assert len(result) == 1
+        mock_forward.assert_called_once_with("textDocument/declaration", params, "file:///mod/Foo.java")
+
+    async def test_on_prepare_rename_forwards_to_jdtls(self) -> None:
+        """_on_prepare_rename forwards and structures a Range result."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_prepare_rename
+
+        params = lsp.PrepareRenameParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=3, character=5),
+        )
+        raw = {"start": {"line": 3, "character": 4}, "end": {"line": 3, "character": 7}}
+        mock_forward = AsyncMock(return_value=raw)
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_prepare_rename(params)
+        assert result is not None
+        mock_forward.assert_called_once_with("textDocument/prepareRename", params, "file:///mod/Foo.java")
+
+    async def test_on_workspace_symbol_uses_proxy_directly(self) -> None:
+        """_on_workspace_symbol bypasses _ensure_module_and_forward and calls proxy.send_request."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_workspace_symbol
+        from java_functional_lsp.server import server as srv
+
+        params = lsp.WorkspaceSymbolParams(query="Foo")
+        raw = [
+            {
+                "name": "FooService",
+                "kind": 5,
+                "location": {
+                    "uri": "file:///mod/FooService.java",
+                    "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 10}},
+                },
+            }
+        ]
+        mock_send = AsyncMock(return_value=raw)
+        with (
+            patch.object(srv._proxy, "_available", True),
+            patch.object(srv._proxy, "send_request", mock_send),
+        ):
+            result = await _on_workspace_symbol(params)
+        assert result is not None
+        assert len(result) == 1
+        assert result[0].name == "FooService"
+        mock_send.assert_called_once()
+        assert mock_send.call_args[0][0] == "workspace/symbol"
+
+    async def test_on_workspace_symbol_returns_none_when_unavailable(self) -> None:
+        """_on_workspace_symbol returns None when jdtls is not available."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import _on_workspace_symbol
+        from java_functional_lsp.server import server as srv
+
+        params = lsp.WorkspaceSymbolParams(query="anything")
+        with patch.object(srv._proxy, "_available", False):
+            result = await _on_workspace_symbol(params)
+        assert result is None
+
+    async def test_on_document_highlight_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_document_highlight
+
+        params = lsp.DocumentHighlightParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_document_highlight(params) is None
+
+    async def test_on_type_definition_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_type_definition
+
+        params = lsp.TypeDefinitionParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_type_definition(params) is None
+
+    async def test_on_declaration_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_declaration
+
+        params = lsp.DeclarationParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_declaration(params) is None
+
+    async def test_on_prepare_rename_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_prepare_rename
+
+        params = lsp.PrepareRenameParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_prepare_rename(params) is None
+
+    async def test_on_prepare_rename_returns_placeholder_when_jdtls_sends_placeholder(self) -> None:
+        """_on_prepare_rename handles PrepareRenamePlaceholder (the typical jdtls response)."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_prepare_rename
+
+        params = lsp.PrepareRenameParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=3, character=5),
+        )
+        raw = {
+            "range": {"start": {"line": 3, "character": 4}, "end": {"line": 3, "character": 7}},
+            "placeholder": "foo",
+        }
+        mock_forward = AsyncMock(return_value=raw)
+        with patch("java_functional_lsp.server._ensure_module_and_forward", mock_forward):
+            result = await _on_prepare_rename(params)
+        assert isinstance(result, lsp.PrepareRenamePlaceholder)
+        assert result.placeholder == "foo"
+
+    async def test_on_prepare_type_hierarchy_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_prepare_type_hierarchy
+
+        params = lsp.TypeHierarchyPrepareParams(
+            text_document=lsp.TextDocumentIdentifier(uri="file:///mod/Foo.java"),
+            position=lsp.Position(line=0, character=0),
+        )
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_prepare_type_hierarchy(params) is None
+
+    async def test_on_type_hierarchy_supertypes_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_type_hierarchy_supertypes
+
+        item = lsp.TypeHierarchyItem(
+            name="Foo",
+            kind=lsp.SymbolKind.Class,
+            uri="file:///mod/Foo.java",
+            range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=3)),
+            selection_range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=3)),
+        )
+        params = lsp.TypeHierarchySupertypesParams(item=item)
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_type_hierarchy_supertypes(params) is None
+
+    async def test_on_type_hierarchy_subtypes_returns_none_on_null(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.server import _on_type_hierarchy_subtypes
+
+        item = lsp.TypeHierarchyItem(
+            name="Base",
+            kind=lsp.SymbolKind.Class,
+            uri="file:///mod/Base.java",
+            range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=4)),
+            selection_range=lsp.Range(start=lsp.Position(line=0, character=0), end=lsp.Position(line=0, character=4)),
+        )
+        params = lsp.TypeHierarchySubtypesParams(item=item)
+        with patch("java_functional_lsp.server._ensure_module_and_forward", AsyncMock(return_value=None)):
+            assert await _on_type_hierarchy_subtypes(params) is None
+
     def test_serialize_params_camelcase(self) -> None:
         from java_functional_lsp.server import _serialize_params
 
@@ -611,7 +1171,11 @@ class TestServerInternals:
         finally:
             server.workspace.remove_text_document(uri)
         assert result is not None
-        assert any("Try.of" in e.new_text for e in result[0].edit.changes[uri])
+        ca = result[0]
+        assert isinstance(ca, lsp.CodeAction)
+        assert ca.edit is not None
+        assert ca.edit.changes is not None
+        assert any("Try.of" in e.new_text for e in ca.edit.changes[uri])
 
     def test_code_action_filters_foreign(self) -> None:
         from java_functional_lsp.server import on_code_action, server
@@ -897,7 +1461,7 @@ class TestFindLombokJar:
         result = _find_lombok_jar()
         assert result is None
 
-    def test_warns_on_missing_config_path(self, tmp_path: Any, caplog: Any) -> None:
+    def test_warns_on_missing_config_path(self, caplog: Any) -> None:
         import logging
 
         from java_functional_lsp.proxy import _find_lombok_jar
@@ -1027,6 +1591,7 @@ class TestLspLifecycle:
         assert actions is not None
         assert len(actions) >= 1
         action = actions[0]
+        assert isinstance(action, lsp.CodeAction)
         assert action.title == "Replace with Option.none()"
         assert action.kind == lsp.CodeActionKind.QuickFix
         assert action.edit is not None
@@ -1053,6 +1618,7 @@ class TestLspLifecycle:
         assert actions is not None
         assert len(actions) >= 1
         action = actions[0]
+        assert isinstance(action, lsp.CodeAction)
         assert action.title == "Convert try/catch to Try monadic flow"
         assert action.edit is not None
         assert action.edit.changes is not None

{java_functional_lsp-0.9.4 → java_functional_lsp-0.9.6}/uv.lock

@@ -184,7 +184,7 @@ wheels = [
 
 [[package]]
 name = "java-functional-lsp"
-version = "0.9.0"
+version = "0.9.6"
 source = { editable = "." }
 dependencies = [
     { name = "pygls" },