update

Author: observerw

python/src/lsap/definition.py

@@ -17,15 +17,14 @@
 from lsprotocol.types import Location
 
 from .abc import Capability, ClientProtocol
+from .exception import UnsupportedCapabilityError
 from .locate import LocateCapability
 from .symbol import SymbolCapability
 
 
 @runtime_checkable
 class DefinitionClient(
     WithRequestDefinition,
-    WithRequestDeclaration,
-    WithRequestTypeDefinition,
     WithRequestDocumentSymbol,
     WithRequestHover,
     ClientProtocol,
@@ -59,10 +58,24 @@ async def __call__(self, req: DefinitionRequest) -> DefinitionResponse | None:
                     file_path, lsp_pos
                 )
             case "declaration":
+                if not isinstance(self.client, WithRequestDeclaration):
+                    raise UnsupportedCapabilityError(
+                        "Client does not support 'textDocument/declaration'. "
+                        "To find declarations, you can: "
+                        "1) Use 'definition' mode (most language servers treat them similarly); "
+                        "2) For C/C++, check corresponding header files manually."
+                    )
                 locations = await self.client.request_declaration_locations(
                     file_path, lsp_pos
                 )
             case "type_definition":
+                if not isinstance(self.client, WithRequestTypeDefinition):
+                    raise UnsupportedCapabilityError(
+                        "Client does not support 'textDocument/typeDefinition'. "
+                        "To find type definitions, you can: "
+                        "1) Use 'definition' on the type name itself if visible; "
+                        "2) Use 'hover' to see the type name and then search for it."
+                    )
                 locations = await self.client.request_type_definition_locations(
                     file_path, lsp_pos
                 )

python/src/lsap/exception.py

@@ -11,3 +11,7 @@ class AmbiguousError(LSAPError):
 
 class NotFoundError(LSAPError):
     """Raised when something is not found."""
+
+
+class UnsupportedCapabilityError(LSAPError):
+    """Raised when a capability is not supported by the client."""

python/src/lsap/reference.py

@@ -22,14 +22,14 @@
 from lsap.utils.symbol import symbol_at
 
 from .abc import Capability
+from .exception import UnsupportedCapabilityError
 from .locate import LocateCapability
 from .utils.cache import PaginationCache
 
 
 @runtime_checkable
 class ReferenceClient(
     WithRequestReferences,
-    WithRequestImplementation,
     WithRequestDocumentSymbol,
     WithRequestHover,
     CapabilityClientProtocol,
@@ -61,6 +61,14 @@ async def fetcher() -> list[ReferenceItem] | None:
                 ):
                     locations.extend(refs)
             elif req.mode == "implementations":
+                if not isinstance(self.client, WithRequestImplementation):
+                    raise UnsupportedCapabilityError(
+                        "Client does not support 'textDocument/implementation'. "
+                        "To find implementations, you can: "
+                        "1) Use 'references' mode to find all usages (often including implementations); "
+                        "2) Find the symbol definition and then search for its references; "
+                        "3) Use 'search' or 'symbol' capability to find name-matched definitions."
+                    )
                 if impls := await self.client.request_implementation_locations(
                     file_path, lsp_pos
                 ):

python/tests/test_definition.py

@@ -9,6 +9,7 @@
 from lsprotocol.types import Range as LSPRange
 
 from lsap.definition import DefinitionCapability
+from lsap.exception import UnsupportedCapabilityError
 
 
 class MockDefinitionClient:
@@ -87,3 +88,20 @@ async def test_definition():
     assert resp.items[0].path == ["foo"]
     assert resp.items[0].code is not None
     assert "def foo():" in resp.items[0].code
+
+
+@pytest.mark.asyncio
+async def test_unsupported_declaration():
+    client = MockDefinitionClient()
+    capability = DefinitionCapability(client=client)  # type: ignore
+
+    req = DefinitionRequest(
+        locate=Locate(file_path=Path("main.py"), scope=LineScope(line=2), find="foo"),
+        mode="declaration",
+    )
+
+    with pytest.raises(UnsupportedCapabilityError) as excinfo:
+        await capability(req)
+
+    assert "textDocument/declaration" in str(excinfo.value)
+    assert "definition" in str(excinfo.value)

python/tests/test_outline.py

@@ -1,15 +1,12 @@
 from pathlib import Path
 
 import pytest
-from lsprotocol.types import (
-    DocumentSymbol,
-    Position as LSPPosition,
-    Range as LSPRange,
-    SymbolKind,
-)
+from lsap_schema.outline import OutlineRequest
+from lsprotocol.types import DocumentSymbol, SymbolKind
+from lsprotocol.types import Position as LSPPosition
+from lsprotocol.types import Range as LSPRange
 
 from lsap.outline import OutlineCapability
-from lsap_schema.outline import OutlineRequest
 
 
 class MockOutlineClient:

python/tests/test_reference.py

@@ -7,6 +7,7 @@
     Position as LSPPosition,
     Location,
 )
+from lsap.exception import UnsupportedCapabilityError
 from lsap.reference import ReferenceCapability
 from lsap_schema.reference import ReferenceRequest
 from lsap_schema.locate import LineScope, Locate
@@ -122,3 +123,20 @@ async def test_reference_pagination():
     assert len(resp2.items) == 1
     assert resp2.has_more is False
     assert resp2.pagination_id is None
+
+
+@pytest.mark.asyncio
+async def test_unsupported_implementation():
+    client = MockReferenceClient()
+    capability = ReferenceCapability(client=client)  # type: ignore
+
+    req = ReferenceRequest(
+        locate=Locate(file_path=Path("test.py"), scope=LineScope(line=2), find="foo"),
+        mode="implementations",
+    )
+
+    with pytest.raises(UnsupportedCapabilityError) as excinfo:
+        await capability(req)
+
+    assert "textDocument/implementation" in str(excinfo.value)
+    assert "references" in str(excinfo.value)