implement reporting unused keywords

Author: d-biehl

robotcode/language_server/common/lsp_types.py

@@ -1045,7 +1045,7 @@ class LinkedEditingRangeOptions(WorkDoneProgressOptions):
 
 @dataclass(repr=False)
 class LinkedEditingRangeRegistrationOptions(
-    TextDocumentRegistrationOptions, LinkedEditingRangeOptions, StaticRegistrationOptions
+    LinkedEditingRangeOptions, StaticRegistrationOptions, TextDocumentRegistrationOptions
 ):
     pass
 
@@ -1068,7 +1068,7 @@ class RenameOptions(WorkDoneProgressOptions):
 
 
 @dataclass(repr=False)
-class RenameRegistrationOptions(TextDocumentRegistrationOptions, RenameOptions, StaticRegistrationOptions):
+class RenameRegistrationOptions(RenameOptions, StaticRegistrationOptions, TextDocumentRegistrationOptions):
     pass
 
 
@@ -1078,7 +1078,24 @@ class InlineValueOptions(WorkDoneProgressOptions):
 
 
 @dataclass(repr=False)
-class InlineValueRegistrationOptions(InlineValueOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions):
+class InlineValueRegistrationOptions(TextDocumentRegistrationOptions, StaticRegistrationOptions, InlineValueOptions):
+    pass
+
+
+@dataclass(repr=False)
+class _DiagnosticOptions(Model):
+    inter_file_dependencies: bool
+    workspace_diagnostics: bool
+    identifier: Optional[str] = None
+
+
+@dataclass(repr=False)
+class DiagnosticOptions(WorkDoneProgressOptions, _DiagnosticOptions):
+    pass
+
+
+@dataclass(repr=False)
+class DiagnosticRegistrationOptions(TextDocumentRegistrationOptions, StaticRegistrationOptions, DiagnosticOptions):
     pass
 
 
@@ -1115,6 +1132,9 @@ class ServerCapabilities(Model):
 
     # TODO typeHierarchyProvider?: boolean | TypeHierarchyOptions | TypeHierarchyRegistrationOptions;
     inline_value_provider: Union[bool, InlineValueOptions, InlineValueRegistrationOptions, None] = None
+    # TODO inlayHintProvider?: boolean | InlayHintOptions | InlayHintRegistrationOptions;
+    diagnostic_provider: Union[DiagnosticOptions, DiagnosticRegistrationOptions, None] = None
+
     workspace_symbol_provider: Union[bool, WorkspaceSymbolOptions, None] = None
     workspace: Optional[ServerCapabilitiesWorkspace] = None
     experimental: Optional[Any] = None

robotcode/language_server/common/parts/diagnostics.py

@@ -7,8 +7,10 @@
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, cast
 
 from ....utils.async_tools import (
+    Event,
     Lock,
     async_event,
+    async_tasking_event,
     async_tasking_event_iterator,
     check_canceled,
     create_sub_task,
@@ -147,6 +149,8 @@ def __init__(self, protocol: LanguageServerProtocol) -> None:
         self.parent.documents.did_close.add(self.on_did_close)
         self.parent.documents.did_save.add(self.on_did_save)
 
+        self.workspace_diagnostics_running = Event()
+
     @async_tasking_event_iterator
     async def collect(sender, document: TextDocument) -> DiagnosticsResult:  # NOSONAR
         ...
@@ -155,6 +159,10 @@ async def collect(sender, document: TextDocument) -> DiagnosticsResult:  # NOSON
     async def collect_workspace_documents(sender) -> List[WorkspaceDocumentsResult]:  # NOSONAR
         ...
 
+    @async_tasking_event
+    async def workspace_diagnostics_stopped(sender) -> None:  # NOSONAR
+        ...
+
     @_logger.call
     async def on_connection_lost(self, sender: Any, exc: Optional[BaseException]) -> None:
         await self._cancel_all_tasks()
@@ -203,6 +211,8 @@ async def on_did_append_document(self, sender: Any, document: TextDocument) -> N
     @language_id("robotframework")
     @_logger.call
     async def on_did_open(self, sender: Any, document: TextDocument) -> None:
+        await self.workspace_diagnostics_running.wait()
+
         await self.create_publish_document_diagnostics_task(document)
 
     @language_id("robotframework")
@@ -300,7 +310,8 @@ async def start_publish_document_diagnostics_task(
         )
 
     @_logger.call
-    async def publish_document_diagnostics(self, document_uri: DocumentUri) -> None:
+    async def publish_document_diagnostics(self, document_uri: DocumentUri, threaded: bool = True) -> None:
+
         document = await self.parent.documents.get(document_uri)
         if document is None:
             return
@@ -314,6 +325,7 @@ async def publish_document_diagnostics(self, document_uri: DocumentUri) -> None:
             document,
             callback_filter=language_id_filter(document),
             return_exceptions=True,
+            threaded=threaded,
         ):
             await check_canceled()
 
@@ -327,8 +339,7 @@ async def publish_document_diagnostics(self, document_uri: DocumentUri) -> None:
                 diagnostics[result.key] = result.diagnostics if result.diagnostics else []
                 collected_keys.append(result.key)
 
-                asyncio.get_event_loop().call_soon(
-                    self.parent.send_notification,
+                self.parent.send_notification(
                     "textDocument/publishDiagnostics",
                     PublishDiagnosticsParams(
                         uri=document.document_uri,
@@ -345,32 +356,36 @@ async def publish_document_diagnostics(self, document_uri: DocumentUri) -> None:
     @_logger.call
     async def publish_workspace_diagnostics(self) -> None:
         canceled = False
-
-        async for result_any in self.collect_workspace_documents(
-            self,
-            return_exceptions=True,
-        ):
-            await check_canceled()
-            if canceled:
-                break
-
-            if isinstance(result_any, BaseException):
-                if not isinstance(result_any, asyncio.CancelledError):
-                    self._logger.exception(result_any, exc_info=result_any)
-                    continue
-
-            result = cast(List[WorkspaceDocumentsResult], result_any)
-            async with self.parent.window.progress(
-                "Analyze workspace",
-                cancellable=True,
-                current=0,
-                max=len(result),
-            ) as progress:
-                for i, v in enumerate(result):
-                    if progress.is_canceled:
-                        canceled = True
-                        break
-
-                    progress.report(f"Analyze {v.name}" if v.name else None, cancellable=False, current=i + 1)
-
-                    await self.publish_document_diagnostics(str(v.document.uri))
+        self.workspace_diagnostics_running.clear()
+        try:
+            async for result_any in self.collect_workspace_documents(
+                self,
+                return_exceptions=True,
+            ):
+                await check_canceled()
+                if canceled:
+                    break
+
+                if isinstance(result_any, BaseException):
+                    if not isinstance(result_any, asyncio.CancelledError):
+                        self._logger.exception(result_any, exc_info=result_any)
+                        continue
+
+                result = cast(List[WorkspaceDocumentsResult], result_any)
+                async with self.parent.window.progress(
+                    "Analyze workspace",
+                    cancellable=True,
+                    current=0,
+                    max=len(result),
+                ) as progress:
+                    for i, v in enumerate(result):
+                        if progress.is_canceled:
+                            canceled = True
+                            break
+
+                        progress.report(f"Analyze {v.name}" if v.name else None, cancellable=False, current=i + 1)
+
+                        await self.publish_document_diagnostics(str(v.document.uri))
+        finally:
+            self.workspace_diagnostics_running.set()
+            await self.workspace_diagnostics_stopped(self)

robotcode/language_server/common/parts/documents.py

@@ -16,7 +16,12 @@
 )
 
 from ....jsonrpc2.protocol import JsonRPCException, rpc_method
-from ....utils.async_tools import Lock, async_event, async_tasking_event
+from ....utils.async_tools import (
+    Lock,
+    async_event,
+    async_tasking_event,
+    create_sub_task,
+)
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
 from ..decorators import language_id_filter
@@ -91,20 +96,28 @@ async def _file_watcher(self, sender: Any, changes: List[FileEvent]) -> None:
 
         for change in to_change.values():
             if change.type == FileChangeType.CREATED:
-                await self.did_create_uri(self, change.uri)
+                create_sub_task(self.did_create_uri(self, change.uri), loop=self.parent.loop)
 
             document = self._documents.get(DocumentUri(Uri(change.uri).normalized()), None)
             if document is not None and change.type == FileChangeType.CREATED:
-                await self.did_create(self, document, callback_filter=language_id_filter(document))
+                create_sub_task(
+                    self.did_create(self, document, callback_filter=language_id_filter(document)), loop=self.parent.loop
+                )
             elif document is not None and not document.opened_in_editor:
                 if change.type == FileChangeType.DELETED:
                     await self.close_document(document, True)
-                    await self.did_close(self, document, callback_filter=language_id_filter(document))
+                    create_sub_task(
+                        self.did_close(self, document, callback_filter=language_id_filter(document)),
+                        loop=self.parent.loop,
+                    )
                 elif change.type == FileChangeType.CHANGED:
                     await document.apply_full_change(
                         None, await self.read_document_text(document.uri, language_id_filter(document)), save=True
                     )
-                    await self.did_change(self, document, callback_filter=language_id_filter(document))
+                    create_sub_task(
+                        self.did_change(self, document, callback_filter=language_id_filter(document)),
+                        loop=self.parent.loop,
+                    )
 
     async def read_document_text(self, uri: Uri, language_id: Union[str, Callable[[Any], bool]]) -> str:
         for e in await self.on_read_document_text(
@@ -212,7 +225,10 @@ async def append_document(
 
             self._documents[document_uri] = document
 
-            await self.did_append_document(self, document, callback_filter=language_id_filter(document))
+            create_sub_task(
+                self.did_append_document(self, document, callback_filter=language_id_filter(document)),
+                loop=self.parent.loop,
+            )
 
             return document
 
@@ -245,10 +261,15 @@ async def _text_document_did_open(self, text_document: TextDocumentItem, *args:
 
             document.opened_in_editor = True
 
-        await self.did_open(self, document, callback_filter=language_id_filter(document))
+        create_sub_task(
+            self.did_open(self, document, callback_filter=language_id_filter(document)), loop=self.parent.loop
+        )
 
         if text_changed:
-            await self.did_change(self, document, callback_filter=language_id_filter(document))
+            create_sub_task(
+                self.did_change(self, document, callback_filter=language_id_filter(document)),
+                loop=self.parent.loop,
+            )
 
     @rpc_method(name="textDocument/didClose", param_type=DidCloseTextDocumentParams)
     @_logger.call
@@ -260,8 +281,9 @@ async def _text_document_did_close(self, text_document: TextDocumentIdentifier,
             document.opened_in_editor = False
 
             await self.close_document(document)
-
-            await self.did_close(self, document, callback_filter=language_id_filter(document))
+            create_sub_task(
+                self.did_close(self, document, callback_filter=language_id_filter(document)), loop=self.parent.loop
+            )
 
     @_logger.call
     async def close_document(self, document: TextDocument, real_close: bool = False) -> None:
@@ -274,7 +296,9 @@ async def close_document(self, document: TextDocument, real_close: bool = False)
         else:
             document._version = None
             if await document.revert(None):
-                await self.did_change(self, document, callback_filter=language_id_filter(document))
+                create_sub_task(
+                    self.did_change(self, document, callback_filter=language_id_filter(document)), loop=self.parent.loop
+                )
 
     @rpc_method(name="textDocument/willSave", param_type=WillSaveTextDocumentParams)
     @_logger.call
@@ -299,9 +323,14 @@ async def _text_document_did_save(
                 text_changed = await document.text() != normalized_text
                 if text_changed:
                     await document.save(None, text)
-                    await self.did_change(self, document, callback_filter=language_id_filter(document))
+                    create_sub_task(
+                        self.did_change(self, document, callback_filter=language_id_filter(document)),
+                        loop=self.parent.loop,
+                    )
 
-            await self.did_save(self, document, callback_filter=language_id_filter(document))
+            create_sub_task(
+                self.did_save(self, document, callback_filter=language_id_filter(document)), loop=self.parent.loop
+            )
 
     @rpc_method(name="textDocument/willSaveWaitUntil", param_type=WillSaveTextDocumentParams)
     @_logger.call
@@ -352,4 +381,6 @@ async def _text_document_did_change(
                     f"for document {text_document.uri}."
                 )
 
-        await self.did_change(self, document, callback_filter=language_id_filter(document))
+        create_sub_task(
+            self.did_change(self, document, callback_filter=language_id_filter(document)), loop=self.parent.loop
+        )

robotcode/language_server/robotframework/parts/codelens.py

@@ -29,12 +29,16 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         parent.code_lens.collect.add(self.collect)
         parent.code_lens.resolve.add(self.resolve)
         parent.robot_references.cache_cleared.add(self.robot_references_cache_cleared)
+        parent.diagnostics.workspace_diagnostics_stopped.add(self.diagnostics_workspace_diagnostics_stopped)
 
         self._running_task: Set[Tuple[TextDocument, KeywordDoc]] = set()
 
     async def robot_references_cache_cleared(self, sender: Any) -> None:  # NOSONAR
         await self.parent.code_lens.refresh()
 
+    async def diagnostics_workspace_diagnostics_stopped(self, sender: Any) -> None:  # NOSONAR
+        await self.parent.code_lens.refresh()
+
     @language_id("robotframework")
     @threaded()
     async def collect(self, sender: Any, document: TextDocument) -> Optional[List[CodeLens]]:
@@ -109,7 +113,7 @@ async def resolve(self, sender: Any, code_lens: CodeLens) -> Optional[CodeLens]:
         name = code_lens.data["name"]
         line = code_lens.data["line"]
 
-        if self.parent.robot_workspace.workspace_loaded.is_set():
+        if self.parent.diagnostics.workspace_diagnostics_running.is_set():
             kw_doc = await self.get_keyword_definition_at_line(namespace, name, line)
 
             if kw_doc is not None and not kw_doc.is_error_handler: