feat: New command Clear Cache and Restart Language Servers

Clears all cached data i.e library docs and restarts the language servers.

Author: d-biehl

package.json

@@ -711,6 +711,11 @@
         "title": "Restart Language Servers",
         "category": "RobotCode",
         "command": "robotcode.restartLanguageServers"
+      },
+      {
+        "title": "Clear Cache and Restart Language Servers",
+        "category": "RobotCode",
+        "command": "robotcode.clearCacheRestartLanguageServers"
       }
     ],
     "menus": {

robotcode/jsonrpc2/protocol.py

@@ -618,7 +618,7 @@ def set_result(f: asyncio.Future[Any], r: Any, ev: threading.Event) -> None:
                             await asyncio.sleep(0)
 
                     else:
-                        self._logger.warning(f"Response {entry:r} loop is not running.")
+                        self._logger.warning(f"Response {repr(entry)} loop is not running.")
 
         except (SystemExit, KeyboardInterrupt):
             raise

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -4,6 +4,7 @@
 import asyncio
 import itertools
 import os
+import shutil
 import sys
 import weakref
 import zlib
@@ -503,9 +504,10 @@ def __init__(self, parent_protocol: RobotLanguageServerProtocol, folder: Uri, co
 
         self._logger.trace(lambda: f"use {cache_base_path} as base for caching")
 
+        self.cache_path = cache_base_path / ".robotcode_cache"
+
         self.lib_doc_cache_path = (
-            cache_base_path
-            / ".robotcode_cache"
+            self.cache_path
             / f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
             / get_robot_version_str()
             / "libdoc"
@@ -534,6 +536,11 @@ def __init__(self, parent_protocol: RobotLanguageServerProtocol, folder: Uri, co
     def environment(self) -> Mapping[str, str]:
         return self._environment
 
+    def clear_cache(self) -> None:
+        if self.cache_path.exists():
+            shutil.rmtree(self.cache_path)
+            self._logger.debug(f"Cleared cache {self.cache_path}")
+
     @_logger.call
     async def get_command_line_variables(self) -> List[VariableDefinition]:
         from robot.utils.text import split_args_from_name_or_path
@@ -940,7 +947,7 @@ async def _get_libdoc() -> LibraryDoc:
                         spec_file = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".spec.json"))
                         spec_file.write_text(as_json(result), "utf-8")
                     else:
-                        self._logger.debug(lambda: f"Skip caching library {name}{args:r}")
+                        self._logger.debug(lambda: f"Skip caching library {name}{repr(args)}")
                 except (SystemExit, KeyboardInterrupt):
                     raise
                 except BaseException as e:

robotcode/language_server/robotframework/parts/documents_cache.py

@@ -16,11 +16,10 @@
     cast,
 )
 
-from robotcode.language_server.common.lsp_types import MessageType
-
 from ....utils.async_tools import Lock, async_tasking_event, check_canceled_sync
 from ....utils.uri import Uri
 from ...common.decorators import language_id_filter
+from ...common.lsp_types import MessageType
 from ...common.parts.workspace import WorkspaceFolder
 from ...common.text_document import TextDocument
 from ..configuration import RobotCodeConfig, RobotConfig
@@ -435,7 +434,12 @@ async def default_imports_manager(self) -> ImportsManager:
             return self._default_imports_manager
 
     async def get_imports_manager(self, document: TextDocument) -> ImportsManager:
-        folder = self.parent.workspace.get_workspace_folder(document.uri)
+        return await self.get_imports_manager_for_uri(document.uri)
+
+    async def get_imports_manager_for_uri(self, uri: Uri) -> ImportsManager:
+        return await self.get_imports_manager_for_workspace_folder(self.parent.workspace.get_workspace_folder(uri))
+
+    async def get_imports_manager_for_workspace_folder(self, folder: Optional[WorkspaceFolder]) -> ImportsManager:
         if folder is None:
             if len(self.parent.workspace.workspace_folders) == 1:
                 folder = self.parent.workspace.workspace_folders[0]

robotcode/language_server/robotframework/parts/robot_workspace.py

@@ -4,6 +4,8 @@
 import time
 from typing import TYPE_CHECKING, Any, List, Optional
 
+from robotcode.jsonrpc2.protocol import rpc_method
+
 from ....utils.async_tools import Event, threaded
 from ....utils.glob_path import iter_files
 from ....utils.logging import LoggingDescriptor
@@ -149,3 +151,9 @@ async def _load_workspace_documents(self, sender: Any) -> List[WorkspaceDocument
             return result
         finally:
             self._logger.debug(f"Workspace loaded in {time.monotonic() - start}s")
+
+    @rpc_method(name="robot/cache/clear")
+    @threaded()
+    async def get_tests_from_workspace(self) -> None:
+        for folder in self.parent.workspace.workspace_folders:
+            (await self.parent.documents_cache.get_imports_manager_for_workspace_folder(folder)).clear_cache()

vscode-client/languageclientsmanger.ts

@@ -126,10 +126,20 @@ export class LanguageClientsManager {
       },
       vscode.workspace.onDidChangeWorkspaceFolders(async (_event) => this.refresh()),
       vscode.workspace.onDidOpenTextDocument(async (document) => this.getLanguageClientForDocument(document)),
-      vscode.commands.registerCommand("robotcode.restartLanguageServers", async () => await this.restart())
+      vscode.commands.registerCommand("robotcode.restartLanguageServers", async () => await this.restart()),
+      vscode.commands.registerCommand("robotcode.clearCacheRestartLanguageServers", async () => {
+        await this.clearCaches();
+        await this.restart();
+      })
     );
   }
 
+  public async clearCaches(): Promise<void> {
+    for (const client of this.clients.values()) {
+      await client.sendRequest("robot/cache/clear");
+    }
+  }
+
   public async stopAllClients(): Promise<boolean> {
     const promises: Promise<void>[] = [];