feat(langserver): support for workspace symbols

closes #323

Author: d-biehl

packages/language_server/src/robotcode/language_server/common/parts/workspace_symbols.py

@@ -0,0 +1,132 @@
+from concurrent.futures import CancelledError
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Final,
+    Iterable,
+    List,
+    Optional,
+    Protocol,
+    TypeVar,
+    Union,
+    cast,
+    runtime_checkable,
+)
+
+from robotcode.core.event import event
+from robotcode.core.lsp.types import (
+    Location,
+    ServerCapabilities,
+    SymbolInformation,
+    WorkspaceSymbol,
+    WorkspaceSymbolClientCapabilitiesResolveSupportType,
+    WorkspaceSymbolClientCapabilitiesSymbolKindType,
+    WorkspaceSymbolClientCapabilitiesTagSupportType,
+    WorkspaceSymbolParams,
+)
+from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.jsonrpc2.protocol import rpc_method
+from robotcode.language_server.common.parts.protocol_part import (
+    LanguageServerProtocolPart,
+)
+
+if TYPE_CHECKING:
+    from robotcode.language_server.common.protocol import LanguageServerProtocol
+
+
+@runtime_checkable
+class HasSymbolInformationLabel(Protocol):
+    symbol_information_label: str
+
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+
+def symbol_information_label(label: str) -> Callable[[_F], _F]:
+    def decorator(func: _F) -> _F:
+        setattr(func, "symbol_information_label", label)
+        return func
+
+    return decorator
+
+
+class WorkspaceSymbolsProtocolPart(LanguageServerProtocolPart):
+    _logger: Final = LoggingDescriptor()
+
+    def __init__(self, parent: "LanguageServerProtocol") -> None:
+        super().__init__(parent)
+        self.symbol_kind: Optional[WorkspaceSymbolClientCapabilitiesSymbolKindType] = None
+        self.tag_support: Optional[WorkspaceSymbolClientCapabilitiesTagSupportType] = None
+        self.resolve_support: Optional[WorkspaceSymbolClientCapabilitiesResolveSupportType] = None
+
+    @event
+    def collect(
+        sender,
+        query: str,
+    ) -> Optional[Union[List[WorkspaceSymbol], List[SymbolInformation], None]]: ...
+
+    def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
+        if (
+            self.parent.client_capabilities
+            and self.parent.client_capabilities.workspace
+            and self.parent.client_capabilities.workspace.symbol is not None
+        ):
+            workspace_symbol = self.parent.client_capabilities.workspace.symbol
+
+            self.symbol_kind = workspace_symbol.symbol_kind
+            self.tag_support = workspace_symbol.tag_support
+            self.resolve_support = workspace_symbol.resolve_support
+
+            if len(self.collect):
+                # TODO: Implement workspace resolve
+                capabilities.workspace_symbol_provider = True
+
+    @rpc_method(name="workspace/symbol", param_type=WorkspaceSymbolParams, threaded=True)
+    def _workspace_symbol(
+        self, query: str, *args: Any, **kwargs: Any
+    ) -> Optional[Union[List[WorkspaceSymbol], List[SymbolInformation], None]]:
+        workspace_symbols: List[WorkspaceSymbol] = []
+        symbol_informations: List[SymbolInformation] = []
+
+        for result in self.collect(self, query):
+            if isinstance(result, BaseException):
+                if not isinstance(result, CancelledError):
+                    self._logger.exception(result, exc_info=result)
+            else:
+                if result is not None:
+                    if all(isinstance(e, WorkspaceSymbol) for e in result):
+                        workspace_symbols.extend(cast(Iterable[WorkspaceSymbol], result))
+                    elif all(isinstance(e, SymbolInformation) for e in result):
+                        symbol_informations.extend(cast(Iterable[SymbolInformation], result))
+                    else:
+                        self._logger.warning(
+                            "Result contains WorkspaceSymbol and SymbolInformation results, result is skipped."
+                        )
+
+        if workspace_symbols:
+            for symbol in workspace_symbols:
+                if isinstance(symbol.location, Location):
+                    doc = self.parent.documents.get(symbol.location.uri)
+                    if doc is not None:
+                        symbol.location.range = doc.range_to_utf16(symbol.location.range)
+
+        if symbol_informations:
+            for symbol_information in symbol_informations:
+                doc = self.parent.documents.get(symbol_information.location.uri)
+                if doc is not None:
+                    symbol_information.location.range = doc.range_to_utf16(symbol_information.location.range)
+
+        if workspace_symbols and symbol_informations:
+            self._logger.warning(
+                "Result contains WorksapceSymbol and SymbolInformation results, only WorkspaceSymbols returned."
+            )
+            return workspace_symbols
+
+        if workspace_symbols:
+            return workspace_symbols
+
+        if symbol_informations:
+            return symbol_informations
+
+        return None

packages/language_server/src/robotcode/language_server/common/protocol.py

@@ -71,6 +71,7 @@
 from .parts.signature_help import SignatureHelpProtocolPart
 from .parts.window import WindowProtocolPart
 from .parts.workspace import Workspace
+from .parts.workspace_symbols import WorkspaceSymbolsProtocolPart
 
 __all__ = ["LanguageServerException", "LanguageServerProtocol"]
 
@@ -133,6 +134,7 @@ class LanguageServerProtocol(JsonRPCProtocol):
     inline_value: Final = ProtocolPartDescriptor(InlineValueProtocolPart)
     inlay_hint: Final = ProtocolPartDescriptor(InlayHintProtocolPart)
     code_action: Final = ProtocolPartDescriptor(CodeActionProtocolPart)
+    workspace_symbols: Final = ProtocolPartDescriptor(WorkspaceSymbolsProtocolPart)
 
     name: Optional[str] = None
     short_name: Optional[str] = None

packages/language_server/src/robotcode/language_server/robotframework/parts/document_symbols.py

@@ -94,7 +94,7 @@ def visit_TestCase(self, node: TestCase) -> None:  # noqa: N802
             r = range_from_node(node)
             symbol = DocumentSymbol(
                 name=node.name,
-                kind=SymbolKind.METHOD,
+                kind=SymbolKind.CLASS,
                 range=r,
                 selection_range=r,
                 children=[],

packages/language_server/src/robotcode/language_server/robotframework/parts/workspace_symbols.py

@@ -0,0 +1,89 @@
+from typing import TYPE_CHECKING, Any, List, Optional, Union
+
+from robotcode.core.lsp.types import (
+    Location,
+    SymbolInformation,
+    SymbolKind,
+    SymbolTag,
+    WorkspaceSymbol,
+)
+from robotcode.core.utils.logging import LoggingDescriptor
+
+from .protocol_part import RobotLanguageServerProtocolPart
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol
+
+
+def contains_characters_in_order(main_string: str, check_string: str) -> bool:
+    main_iter = iter(main_string.lower())
+    return all(char in main_iter for char in check_string.lower())
+
+
+class RobotWorkspaceSymbolsProtocolPart(RobotLanguageServerProtocolPart):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
+        super().__init__(parent)
+
+        parent.workspace_symbols.collect.add(self.collect)
+
+    @_logger.call
+    def collect(self, sender: Any, query: str) -> Optional[Union[List[WorkspaceSymbol], List[SymbolInformation], None]]:
+        result: List[WorkspaceSymbol] = []
+
+        for document in self.parent.documents.documents:
+            if document.language_id == "robotframework":
+                namespace = self.parent.documents_cache.get_only_initialized_namespace(document)
+                if namespace is not None:
+                    container_name = namespace.get_library_doc().name
+
+                    for kw_doc in [
+                        v
+                        for v in namespace.get_keyword_references().keys()
+                        if v.source == namespace.source and contains_characters_in_order(v.name, query)
+                    ]:
+                        result.append(
+                            WorkspaceSymbol(
+                                name=kw_doc.name,
+                                kind=SymbolKind.FUNCTION,
+                                location=Location(
+                                    uri=document.document_uri,
+                                    range=kw_doc.range,
+                                ),
+                                tags=[SymbolTag.DEPRECATED] if kw_doc.is_deprecated else None,
+                                container_name=container_name,
+                            )
+                        )
+                    for var in [
+                        v
+                        for v in namespace.get_variable_references().keys()
+                        if v.source == namespace.source and contains_characters_in_order(v.name, query)
+                    ]:
+                        result.append(
+                            WorkspaceSymbol(
+                                name=var.name,
+                                kind=SymbolKind.VARIABLE,
+                                location=Location(
+                                    uri=document.document_uri,
+                                    range=var.range,
+                                ),
+                                container_name=container_name,
+                            )
+                        )
+
+                    for test in [
+                        v for v in namespace.get_testcase_definitions() if contains_characters_in_order(v.name, query)
+                    ]:
+                        result.append(
+                            WorkspaceSymbol(
+                                name=test.name,
+                                kind=SymbolKind.CLASS,
+                                location=Location(
+                                    uri=document.document_uri,
+                                    range=test.range,
+                                ),
+                                container_name=container_name,
+                            )
+                        )
+        return result

packages/language_server/src/robotcode/language_server/robotframework/protocol.py

@@ -52,6 +52,7 @@
 from .parts.selection_range import RobotSelectionRangeProtocolPart
 from .parts.semantic_tokens import RobotSemanticTokenProtocolPart
 from .parts.signature_help import RobotSignatureHelpProtocolPart
+from .parts.workspace_symbols import RobotWorkspaceSymbolsProtocolPart
 
 if TYPE_CHECKING:
     from .server import RobotLanguageServer
@@ -118,6 +119,7 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
     robot_debugging_utils = ProtocolPartDescriptor(RobotDebuggingUtilsProtocolPart)
     robot_keywords_treeview = ProtocolPartDescriptor(RobotKeywordsTreeViewPart)
     robot_project_info = ProtocolPartDescriptor(ProjectInfoPart)
+    robot_workspace_symbols = ProtocolPartDescriptor(RobotWorkspaceSymbolsProtocolPart)
 
     http_server = ProtocolPartDescriptor(HttpServerProtocolPart)
 

packages/robot/src/robotcode/robot/diagnostics/entities.py

@@ -394,3 +394,39 @@ def __hash__(self) -> int:
                 self.import_source,
             )
         )
+
+
+@dataclass
+class TestCaseDefinition(SourceEntity):
+    name: str
+
+    @single_call
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.line_no,
+                self.col_offset,
+                self.end_line_no,
+                self.end_col_offset,
+                self.source,
+                self.name,
+            )
+        )
+
+
+@dataclass
+class TagDefinition(SourceEntity):
+    name: str
+
+    @single_call
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.line_no,
+                self.col_offset,
+                self.end_line_no,
+                self.end_col_offset,
+                self.source,
+                self.name,
+            )
+        )

packages/robot/src/robotcode/robot/diagnostics/namespace.py

@@ -72,6 +72,8 @@
     LocalVariableDefinition,
     ResourceEntry,
     ResourceImport,
+    TagDefinition,
+    TestCaseDefinition,
     TestVariableDefinition,
     VariableDefinition,
     VariableMatcher,
@@ -720,6 +722,9 @@ def __init__(
         self._local_variable_assignments: Dict[VariableDefinition, Set[Range]] = {}
         self._namespace_references: Dict[LibraryEntry, Set[Location]] = {}
 
+        self._test_case_definitions: List[TestCaseDefinition] = []
+        self._tag_definitions: List[TagDefinition] = []
+
         self._imported_keywords: Optional[List[KeywordDoc]] = None
         self._imported_keywords_lock = RLock(default_timeout=120, name="Namespace.imported_keywords")
         self._keywords: Optional[List[KeywordDoc]] = None
@@ -847,18 +852,21 @@ def get_keyword_references(self) -> Dict[KeywordDoc, Set[Location]]:
 
         return self._keyword_references
 
-    def get_variable_references(
-        self,
-    ) -> Dict[VariableDefinition, Set[Location]]:
+    def get_variable_references(self) -> Dict[VariableDefinition, Set[Location]]:
         self.ensure_initialized()
 
         self.analyze()
 
         return self._variable_references
 
-    def get_local_variable_assignments(
-        self,
-    ) -> Dict[VariableDefinition, Set[Range]]:
+    def get_testcase_definitions(self) -> List[TestCaseDefinition]:
+        self.ensure_initialized()
+
+        self.analyze()
+
+        return self._test_case_definitions
+
+    def get_local_variable_assignments(self) -> Dict[VariableDefinition, Set[Range]]:
         self.ensure_initialized()
 
         self.analyze()
@@ -1910,6 +1918,8 @@ def analyze(self) -> None:
                         self._variable_references = result.variable_references
                         self._local_variable_assignments = result.local_variable_assignments
                         self._namespace_references = result.namespace_references
+                        self._test_case_definitions = result.test_case_definitions
+                        self._tag_definitions = result.tag_definitions
 
                         lib_doc = self.get_library_doc()