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

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

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

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

{java_functional_lsp-0.9.4 → java_functional_lsp-0.9.7}/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)
 
@@ -636,7 +660,24 @@ async def _lazy_start_jdtls(file_uri: str) -> None:
 # they only activate after jdtls starts.
 
 
-async def _ensure_module_and_forward(method: str, params: Any, file_uri: str) -> Any | None:
+# Methods that operate on a single file and succeed before cross-file indexing
+# is complete. A successful response from these does NOT mean the module is fully
+# indexed, so we must NOT use them to transition the module to READY — doing so
+# would cause cross-file requests (references, callHierarchy) to skip the wait
+# and return empty results from an under-indexed jdtls instance.
+_LIGHTWEIGHT_METHODS: frozenset[str] = frozenset(
+    {
+        "textDocument/documentHighlight",
+        "textDocument/documentSymbol",
+    }
+)
+
+
+async def _ensure_module_and_forward(
+    method: str,
+    params: Any,
+    file_uri: str,
+) -> Any | None:
     """Forward a request to jdtls, ensuring the file's module is loaded.
 
     Uses ``ModuleRegistry`` for adaptive waiting:
@@ -644,8 +685,11 @@ async def _ensure_module_and_forward(method: str, params: Any, file_uri: str) ->
     - **UNKNOWN**: add module, wait until ready (adaptive, not fixed sleep)
     - **ADDED**: module sent but not confirmed — wait until ready
 
-    When a request succeeds, marks the module as READY so subsequent
-    requests skip the wait entirely.
+    When a request that requires full project indexing succeeds, marks the
+    module as READY so subsequent requests skip the wait entirely.
+    Methods in ``_LIGHTWEIGHT_METHODS`` operate on a single file and succeed
+    before cross-file indexing completes — their success is never used to
+    signal readiness.
     """
     proxy = server._proxy
     if not proxy.is_available:
@@ -663,9 +707,10 @@ async def _ensure_module_and_forward(method: str, params: Any, file_uri: str) ->
     serialized = _serialize_params(params)
     result = await proxy.send_request(method, serialized)
 
+    can_mark_ready = method not in _LIGHTWEIGHT_METHODS
     if result is not None:
-        # Success — mark module as ready so future requests are instant.
-        if module_uri:
+        # Success — mark module as ready so future cross-file requests are instant.
+        if can_mark_ready and module_uri:
             proxy.modules.mark_ready(module_uri)
         return result
 
@@ -677,7 +722,7 @@ async def _ensure_module_and_forward(method: str, params: Any, file_uri: str) ->
         await proxy.modules.wait_until_ready(wait_uri, timeout=5.0)
     # Always retry once after waiting — even on timeout the module may be ready.
     result = await proxy.send_request(method, serialized)
-    if result is not None and module_uri:
+    if result is not None and can_mark_ready and module_uri:
         proxy.modules.mark_ready(module_uri)
     return result
 
@@ -739,6 +784,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 +984,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,
     }
 )