implement keyword references

Author: d-biehl

package.json

@@ -348,6 +348,21 @@
             "description": "Defines if the test report should be opened a run session automatically.",
             "scope": "resource"
           },
+          "robotcode.workspace.excludePatterns": {
+            "type": "array",
+            "default": [
+              "**/.git/**",
+              "**/node_modules/**",
+              "**/.pytest_cache/**",
+              "**/__pycache__/**",
+              "**/.mypy_cache/**"
+            ],
+            "items": {
+              "type": "string"
+            },
+            "description": "Specifies glob patterns for excluding files and folders from analysing by the language server.",
+            "scope": "resource"
+          },
           "robotcode.robocop.enabled": {
             "type": "boolean",
             "default": true,

robotcode/language_server/common/lsp_types.py

@@ -28,7 +28,15 @@ def __repr__(self) -> str:
         args = ", ".join(
             f"{f.name}={getattr(self, f.name)!r}"
             for f in dataclasses.fields(self)
-            if f.repr and f.default != getattr(self, f.name)
+            if f.repr
+            and (
+                (f.default == dataclasses.MISSING and f.default_factory == dataclasses.MISSING)  # type: ignore
+                or (f.default != dataclasses.MISSING and f.default != getattr(self, f.name))
+                or (
+                    f.default_factory != dataclasses.MISSING  # type: ignore
+                    and getattr(self, f.name) != f.default_factory()  # type: ignore
+                )
+            )
         )
         return f"{self.__class__.__qualname__}({args})"
 
@@ -913,6 +921,16 @@ class SemanticTokensRegistrationOptions(
     pass
 
 
+@dataclass(repr=False)
+class ReferenceOptions(WorkDoneProgressOptions):
+    pass
+
+
+@dataclass(repr=False)
+class ReferenceRegistrationOptions(TextDocumentRegistrationOptions, ReferenceOptions):
+    pass
+
+
 @dataclass(repr=False)
 class ServerCapabilities(Model):
     text_document_sync: Union[TextDocumentSyncOptions, TextDocumentSyncKind, None] = None
@@ -922,7 +940,7 @@ class ServerCapabilities(Model):
     declaration_provider: Union[bool, DeclarationOptions, DeclarationRegistrationOptions, None] = None
     definition_provider: Union[bool, DefinitionOptions, None] = None
     implementation_provider: Union[bool, ImplementationOptions, ImplementationRegistrationOptions, None] = None
-    # references_provider: Union[bool, ReferenceOptions, None] = None
+    references_provider: Union[bool, ReferenceOptions, None] = None
     # document_highlight_provider: Union[bool, DocumentHighlightOptions, None] = None
     document_symbol_provider: Union[bool, DocumentSymbolOptions, None] = None
     # code_action_provider: Union[bool, CodeActionOptions] = None
@@ -1798,3 +1816,18 @@ class SemanticTokenModifiers(Enum):
 
     def __repr__(self) -> str:  # pragma: no cover
         return super().__str__()
+
+
+@dataclass(repr=False)
+class ReferenceContext(Model):
+    include_declaration: bool
+
+
+@dataclass(repr=False)
+class _ReferenceParams(Model):
+    context: ReferenceContext
+
+
+@dataclass(repr=False)
+class ReferenceParams(WorkDoneProgressParams, PartialResultParams, TextDocumentPositionParams, _ReferenceParams):
+    pass

robotcode/language_server/common/parts/references.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from asyncio import CancelledError
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from ....jsonrpc2.protocol import rpc_method
+from ....utils.async_event import async_tasking_event
+from ....utils.logging import LoggingDescriptor
+from ..has_extend_capabilities import HasExtendCapabilities
+from ..language import HasLanguageId
+from ..lsp_types import (
+    Location,
+    Position,
+    ReferenceContext,
+    ReferenceOptions,
+    ReferenceParams,
+    ServerCapabilities,
+    TextDocumentIdentifier,
+)
+from ..text_document import TextDocument
+
+if TYPE_CHECKING:
+    from ..protocol import LanguageServerProtocol
+
+from .protocol_part import LanguageServerProtocolPart
+
+
+class ReferencesProtocolPart(LanguageServerProtocolPart, HasExtendCapabilities):
+
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: LanguageServerProtocol) -> None:
+        super().__init__(parent)
+
+    def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
+        if len(self.collect):
+            capabilities.references_provider = ReferenceOptions(work_done_progress=True)
+
+    @async_tasking_event
+    async def collect(
+        sender, document: TextDocument, position: Position, context: ReferenceContext
+    ) -> Optional[List[Location]]:
+        ...
+
+    @rpc_method(name="textDocument/references", param_type=ReferenceParams)
+    async def _text_document_references(
+        self,
+        text_document: TextDocumentIdentifier,
+        position: Position,
+        context: ReferenceContext,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[List[Location]]:
+
+        locations: List[Location] = []
+
+        document = self.parent.documents[text_document.uri]
+        for result in await self.collect(
+            self,
+            document,
+            position,
+            context,
+            callback_filter=lambda c: not isinstance(c, HasLanguageId) or c.__language_id__ == document.language_id,
+        ):
+            if isinstance(result, BaseException):
+                if not isinstance(result, CancelledError):
+                    self._logger.exception(result, exc_info=result)
+            else:
+                if result is not None:
+                    locations.extend(result)
+
+        if len(locations) == 0:
+            return None
+
+        return locations

robotcode/language_server/common/parts/workspace.py

@@ -29,6 +29,7 @@
 from ....utils.logging import LoggingDescriptor
 from ....utils.path import path_is_relative_to
 from ....utils.uri import Uri
+from ...common.has_extend_capabilities import HasExtendCapabilities
 from ..lsp_types import (
     ConfigurationItem,
     ConfigurationParams,
@@ -128,7 +129,7 @@ class ConfigBase(Model):
 _F = TypeVar("_F", bound=Callable[..., Any])
 
 
-class Workspace(LanguageServerProtocolPart):
+class Workspace(LanguageServerProtocolPart, HasExtendCapabilities):
     _logger = LoggingDescriptor()
 
     def __init__(
@@ -140,6 +141,7 @@ def __init__(
     ):
         super().__init__(parent)
         self.root_uri = root_uri
+
         self.root_path = root_path
         self.workspace_folders_lock = asyncio.Lock()
         self.workspace_folders: List[WorkspaceFolder] = (

robotcode/language_server/common/protocol.py

@@ -47,6 +47,7 @@
 from .parts.formatting import FormattingProtocolPart
 from .parts.hover import HoverProtocolPart
 from .parts.implementation import ImplementationProtocolPart
+from .parts.references import ReferencesProtocolPart
 from .parts.semantic_tokens import SemanticTokensProtocolPart
 from .parts.signature_help import SignatureHelpProtocolPart
 from .parts.window import WindowProtocolPart
@@ -77,6 +78,7 @@ class LanguageServerProtocol(JsonRPCProtocol):
     document_symbols = ProtocolPartDescriptor(DocumentSymbolsProtocolPart)
     formatting = ProtocolPartDescriptor(FormattingProtocolPart)
     semantic_tokens = ProtocolPartDescriptor(SemanticTokensProtocolPart)
+    references = ProtocolPartDescriptor(ReferencesProtocolPart)
 
     name: Optional[str] = None
     version: Optional[str] = None

robotcode/language_server/robotframework/configuration.py

@@ -43,9 +43,16 @@ class RoboTidyConfig(ConfigBase):
     enabled: bool = True
 
 
+@config_section("robotcode.workspace")
+@dataclass
+class WorkspaceConfig(ConfigBase):
+    exclude_patterns: List[str] = field(default_factory=list)
+
+
 @config_section("robotcode")
 @dataclass
 class RobotCodeConfig(ConfigBase):
     language_server: LanguageServerConfig = LanguageServerConfig()
     robot: RobotConfig = RobotConfig()
     syntax: SyntaxConfig = SyntaxConfig()
+    workspace: WorkspaceConfig = WorkspaceConfig()

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -13,7 +13,7 @@
 from ....utils.logging import LoggingDescriptor
 from ....utils.path import path_is_relative_to
 from ....utils.uri import Uri
-from ...common.lsp_types import DocumentUri, FileChangeType, FileEvent
+from ...common.lsp_types import FileChangeType, FileEvent
 from ...common.parts.workspace import FileWatcherEntry
 from ...common.text_document import TextDocument
 from ..configuration import RobotConfig
@@ -641,8 +641,6 @@ async def _get_entry_for_resource_import(self, name: str, base_dir: str, sentine
         source = await self.find_file(name, base_dir, "Resource")
 
         async def _get_document() -> TextDocument:
-            from robot.utils import FileReader
-
             self._logger.debug(lambda: f"Load resource {name} from source {source}")
 
             source_path = Path(source).resolve()
@@ -653,18 +651,7 @@ async def _get_document() -> TextDocument:
                     f"Supported extensions are {', '.join(repr(s) for s in RESOURCE_EXTENSIONS)}."
                 )
 
-            source_uri = DocumentUri(Uri.from_path(source_path).normalized())
-
-            result = self.parent_protocol.documents.get(source_uri, None)
-            if result is not None:
-                return result
-
-            with FileReader(source_path) as reader:
-                text = str(reader.read())
-
-            return self.parent_protocol.documents.append_document(
-                document_uri=source_uri, language_id="robotframework", text=text
-            )
+            return self.parent_protocol.robot_workspace.get_or_open_document(source_path, "robotframework")
 
         async with self._resources_lock:
             entry_key = _ResourcesEntryKey(source)

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -887,7 +887,6 @@ def __init__(
         self._diagnostics: List[Diagnostic] = []
 
         self._keywords: Optional[List[KeywordDoc]] = None
-        self._loop = asyncio.get_event_loop()
 
         # TODO: how to get the search order from model
         self.search_order: Tuple[str, ...] = ()
@@ -954,29 +953,33 @@ async def get_library_doc(self) -> LibraryDoc:
 
     @_logger.call
     async def ensure_initialized(self) -> bool:
-        async with self._initialize_lock:
+        if not self._initialized:
+            async with self._initialize_lock:
+                if not self._initialized:
+                    imports = await self.get_imports()
+
+                    if self.document is not None:
+
+                        old_imports: List[Import] = self.document.get_data(Namespace)
+                        if old_imports is None:
+                            self.document.set_data(Namespace, imports)
+                        elif old_imports != imports:
+                            new_imports = []
+                            for e in old_imports:
+                                if e in imports:
+                                    new_imports.append(e)
+                            for e in imports:
+                                if e not in new_imports:
+                                    new_imports.append(e)
+                            self.document.set_data(Namespace, new_imports)
+
+                    await self._import_default_libraries()
+                    await self._import_imports(imports, str(Path(self.source).parent), top_level=True)
+
+                    self._initialized = True
+
             if not self._initialized:
-                imports = await self.get_imports()
-
-                if self.document is not None:
-
-                    old_imports: List[Import] = self.document.get_data(Namespace)
-                    if old_imports is None:
-                        self.document.set_data(Namespace, imports)
-                    elif old_imports != imports:
-                        new_imports = []
-                        for e in old_imports:
-                            if e in imports:
-                                new_imports.append(e)
-                        for e in imports:
-                            if e not in new_imports:
-                                new_imports.append(e)
-                        self.document.set_data(Namespace, new_imports)
-
-                await self._import_default_libraries()
-                await self._import_imports(imports, str(Path(self.source).parent), top_level=True)
-
-                self._initialized = True
+                raise Exception("Namespace not initialized")
         return self._initialized
 
     @property
@@ -1383,42 +1386,40 @@ async def get_keywords(self) -> List[KeywordDoc]:
     async def _analyze(self) -> None:
         if not self._analyzed:
             async with self._analyze_lock:
-                try:
-                    self._diagnostics += await Analyzer().get(self.model, self)
+                if not self._analyzed:
+                    try:
+                        self._diagnostics += await Analyzer().get(self.model, self)
 
-                    lib_doc = await self.get_library_doc()
+                        lib_doc = await self.get_library_doc()
 
-                    if lib_doc.errors is not None:
-                        for err in lib_doc.errors:
-                            self._diagnostics.append(
-                                Diagnostic(
-                                    range=Range(
-                                        start=Position(
-                                            line=((err.line_no - 1) if err.line_no is not None else 0),
-                                            character=0,
-                                        ),
-                                        end=Position(
-                                            line=((err.line_no - 1) if err.line_no is not None else 0),
-                                            character=0,
+                        if lib_doc.errors is not None:
+                            for err in lib_doc.errors:
+                                self._diagnostics.append(
+                                    Diagnostic(
+                                        range=Range(
+                                            start=Position(
+                                                line=((err.line_no - 1) if err.line_no is not None else 0),
+                                                character=0,
+                                            ),
+                                            end=Position(
+                                                line=((err.line_no - 1) if err.line_no is not None else 0),
+                                                character=0,
+                                            ),
                                         ),
-                                    ),
-                                    message=err.message,
-                                    severity=DiagnosticSeverity.ERROR,
-                                    source=DIAGNOSTICS_SOURCE_NAME,
-                                    code=err.type_name,
+                                        message=err.message,
+                                        severity=DiagnosticSeverity.ERROR,
+                                        source=DIAGNOSTICS_SOURCE_NAME,
+                                        code=err.type_name,
+                                    )
                                 )
-                            )
-                finally:
-                    self._analyzed = True
+                    finally:
+                        self._analyzed = True
 
     async def find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
         await self.ensure_initialized()
 
         return await KeywordFinder(self).find_keyword(name)
 
-    async def find_keyword_threadsafe(self, name: Optional[str]) -> Optional[KeywordDoc]:
-        return await asyncio.wrap_future(asyncio.run_coroutine_threadsafe(self.find_keyword(name), self._loop))
-
 
 class DiagnosticsEntry(NamedTuple):
     message: str
@@ -1475,7 +1476,6 @@ async def _find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
         return result
 
     async def _get_keyword_from_self(self, name: str) -> Optional[KeywordDoc]:
-
         return (await self.namespace.get_library_doc()).keywords.get(name, None)
 
     async def _yield_owner_and_kw_names(self, full_name: str) -> AsyncIterator[Tuple[str, ...]]: