simplify starting and canceling diagnostics, remove unneeded log entries, use workspace folder for discover tests

Author: d-biehl

log.ini

@@ -10,11 +10,11 @@ keys: root,server,language_server,language_server_parts,jsonrpc2,jsonrpc2_messag
 
 [formatters]
 #keys: detailed,simple,colored_simple
-keys: detailed,simple
+keys: detailed,simple,colored_detailed
 
 [handlers]
-#keys: console, colored_console
-keys: console
+keys: console, colored_console
+#keys: console
 
 [formatter_simple]
 #format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
@@ -29,7 +29,8 @@ format: %(name)s:%(levelname)s:  %(message)s
 format: %(name)s:%(levelname)s %(threadName)s(%(thread)d) %(module)s:%(funcName)s:  %(message)s (%(pathname)s:%(lineno)d)
 
 [formatter_colored_detailed]
-format: %(name)s:%(levelname)s %(module)s:%(lineno)d:  %(message)s
+class: coloredlogs.ColoredFormatter
+format: %(name)s:%(levelname)s %(threadName)s(%(thread)d) %(module)s:%(funcName)s:  %(message)s (%(pathname)s:%(lineno)d)
 
 [handler_console]
 class: StreamHandler
@@ -39,7 +40,7 @@ formatter: detailed
 [handler_colored_console]
 class: StreamHandler
 args: []
-formatter: colored_simple
+formatter: colored_detailed
 
 [logger_root]
 level: INFO

poetry.lock

@@ -58,6 +58,7 @@ robotframework-robocop = "^1.7.1"
 robotframework-tidy = "^1.5.1"
 PyYAML = "^6.0"
 types-PyYAML = "^6.0"
+snakeviz = "^2.1.1"
 
 
 [tool.poetry-dynamic-versioning]

pyproject.toml

@@ -26,7 +26,7 @@
 
 __all__ = ["DiagnosticsProtocolPart", "DiagnosticsResult"]
 
-DIAGNOSTICS_DEBOUNCE = 1.5
+DIAGNOSTICS_DEBOUNCE = 0.75
 
 
 class PublishDiagnosticsEntry:
@@ -52,27 +52,24 @@ def __init__(
         self.cancel_token = cancelation_token
         self.done = False
 
-        @PublishDiagnosticsEntry._logger.call
-        def create_task() -> None:
-            self._future = self._factory()
+        def _done(t: asyncio.Future[Any]) -> None:
+            self.done = True
+            self.done_callback(self)
 
-            if self._future is not None:
+        self._future = create_sub_task(self._wait_and_run())
+        self._future.add_done_callback(_done)
 
-                def _done(t: asyncio.Future[Any]) -> None:
-                    self._future = None
-                    self.done = True
-                    self.done_callback(self)
+    async def _wait_and_run(self) -> None:
+        await asyncio.sleep(DIAGNOSTICS_DEBOUNCE)
+        await self._factory()
 
-                self._future.add_done_callback(_done)
-
-        self._timer_handle: asyncio.TimerHandle = asyncio.get_running_loop().call_later(
-            DIAGNOSTICS_DEBOUNCE, create_task
-        )
-
-    @_logger.call
     def __del__(self) -> None:
         if not self.done:
-            self.cancel()
+            try:
+                if asyncio.get_running_loop():
+                    create_sub_task(self.cancel())
+            except RuntimeError:
+                pass
 
     @property
     def future(self) -> Optional[asyncio.Future[Any]]:
@@ -85,33 +82,28 @@ def __repr__(self) -> str:
         return f"{type(self)}(document={repr(self.uri)}, task={repr(self.future)}, done={self.done})"
 
     @_logger.call
-    def cancel(self) -> asyncio.Future[None]:
-        async def cancel(t: Optional[asyncio.Future[Any]]) -> None:
-            if t is None:
-                return
-
-            if not t.done() and not t.cancelled():
-                t.cancel()
-                try:
-                    await t
-                except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
-                    raise
-
-                except BaseException as ex:
-                    self._logger.exception(ex)
-                    raise
+    async def cancel(self) -> None:
+        if self.future is None:
+            return
 
         if not self.done:
-            self._timer_handle.cancel()
-
             self.cancel_token.cancel()
 
         self.done = True
 
-        try:
-            return create_sub_task(cancel(self.future))
-        finally:
-            self._future = None
+        if not self.future.done() and not self.future.cancelled():
+            self.future.cancel()
+            try:
+                await self.future
+            except (asyncio.CancelledError):
+                pass
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException as ex:
+                self._logger.exception(ex)
+                raise
+            finally:
+                self._future = None
 
 
 @dataclass
@@ -174,21 +166,30 @@ async def _cancel_entry(self, entry: Optional[PublishDiagnosticsEntry]) -> None:
     @language_id("robotframework")
     @_logger.call
     async def on_did_open(self, sender: Any, document: TextDocument) -> None:
-        await self.start_publish_diagnostics_task(document)
+        create_sub_task(self.start_publish_diagnostics_task(document))
 
     @language_id("robotframework")
     @_logger.call
     async def on_did_save(self, sender: Any, document: TextDocument) -> None:
-        await self.start_publish_diagnostics_task(document)
+        create_sub_task(self.start_publish_diagnostics_task(document))
 
     @language_id("robotframework")
     @_logger.call
     async def on_did_close(self, sender: Any, document: TextDocument) -> None:
         await self._cancel_entry(self._running_diagnostics.get(document.uri, None))
 
+        self.parent.send_notification(
+            "textDocument/publishDiagnostics",
+            PublishDiagnosticsParams(
+                uri=document.document_uri,
+                version=document._version,
+                diagnostics=[],
+            ),
+        )
+
     @_logger.call
     async def on_did_change(self, sender: Any, document: TextDocument) -> None:
-        await self.start_publish_diagnostics_task(document)
+        create_sub_task(self.start_publish_diagnostics_task(document))
 
     @_logger.call
     def _delete_entry(self, e: PublishDiagnosticsEntry) -> None:

robotcode/language_server/common/parts/diagnostics.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import uuid
 import weakref
 from dataclasses import dataclass
@@ -418,7 +419,8 @@ async def add_file_watchers(
 
             def remove() -> None:
                 try:
-                    create_sub_task(self.remove_file_watcher_entry(entry))
+                    if asyncio.get_running_loop():
+                        create_sub_task(self.remove_file_watcher_entry(entry))
                 except RuntimeError:
                     pass
 

robotcode/language_server/common/parts/workspace.py

@@ -41,6 +41,19 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
     async def namespace_invalidated(self, sender: Any, document: TextDocument) -> None:
         await self.parent.diagnostics.start_publish_diagnostics_task(document)
 
+    @language_id("robotframework")
+    async def collect_namespace_diagnostics(
+        self, sender: Any, document: TextDocument, cancelation_token: CancelationToken
+    ) -> DiagnosticsResult:
+        async def run() -> List[Diagnostic]:
+            namespace = await self.parent.documents_cache.get_namespace(document)
+            if namespace is None:
+                return DiagnosticsResult(self.collect_namespace_diagnostics, None)
+
+            return await namespace.get_diagnostisc(cancelation_token)
+
+        return DiagnosticsResult(self.collect_namespace_diagnostics, await run_coroutine_in_thread(run))
+
     def _create_error_from_node(self, node: ast.AST, msg: str, source: Optional[str] = None) -> Diagnostic:
         return Diagnostic(
             range=Range(
@@ -67,7 +80,7 @@ def _create_error_from_token(self, token: Token, source: Optional[str] = None) -
     async def collect_token_errors(
         self, sender: Any, document: TextDocument, cancelation_token: CancelationToken
     ) -> DiagnosticsResult:
-        async def collect_async() -> List[Diagnostic]:
+        async def run() -> List[Diagnostic]:
             from robot.errors import VariableError
             from robot.parsing.lexer.tokens import Token
 
@@ -81,6 +94,7 @@ async def collect_async() -> List[Diagnostic]:
 
                     try:
                         for variable_token in token.tokenize_variables():
+                            await check_canceled()
                             if variable_token == token:
                                 break
 
@@ -121,14 +135,14 @@ async def collect_async() -> List[Diagnostic]:
 
             return result
 
-        return DiagnosticsResult(self.collect_token_errors, await run_coroutine_in_thread(collect_async))
+        return DiagnosticsResult(self.collect_token_errors, await run_coroutine_in_thread(run))
 
     @language_id("robotframework")
     @_logger.call(entering=True, exiting=True, exception=True)
     async def collect_walk_model_errors(
         self, sender: Any, document: TextDocument, cancelation_token: CancelationToken
     ) -> DiagnosticsResult:
-        async def collect_async() -> List[Diagnostic]:
+        async def run() -> List[Diagnostic]:
             from ..utils.ast import HasError, HasErrors
             from ..utils.async_ast import iter_nodes
 
@@ -149,26 +163,5 @@ async def collect_async() -> List[Diagnostic]:
 
         return DiagnosticsResult(
             self.collect_walk_model_errors,
-            await run_coroutine_in_thread(collect_async),
+            await run_coroutine_in_thread(run),
         )
-
-    @language_id("robotframework")
-    async def collect_namespace_diagnostics(
-        self, sender: Any, document: TextDocument, cancelation_token: CancelationToken
-    ) -> DiagnosticsResult:
-        async def collect_async() -> List[Diagnostic]:
-            self._logger.debug(f"start collect_namespace_diagnostics for {document}")
-            try:
-                namespace = await self.parent.documents_cache.get_namespace(document)
-                if namespace is None:
-                    return DiagnosticsResult(self.collect_namespace_diagnostics, None)
-
-                return await namespace.get_diagnostisc(cancelation_token)
-            except BaseException as e:
-                self._logger.debug(f"exception in collect_namespace_diagnostics {type(e)}: {e}")
-                raise
-            finally:
-                self._logger.debug("end collect_namespace_diagnostics")
-
-        r = await run_coroutine_in_thread(collect_async)
-        return DiagnosticsResult(self.collect_namespace_diagnostics, r)