only watch for documents handled by the language server, to prevent unexpected restarts from lsp client

Author: d-biehl

robotcode/language_server/common/parts/documents.py

@@ -57,7 +57,12 @@ async def _protocol_initialized(self, sender: Any) -> None:
         await self._update_filewatchers()
 
     async def _update_filewatchers(self) -> None:
-        await self.parent.workspace.add_file_watcher(self._file_watcher, "**/*", WatchKind.CHANGE | WatchKind.DELETE)
+        if self.parent.file_extensions:
+            await self.parent.workspace.add_file_watcher(
+                self._file_watcher,
+                f"**/*.{{{','.join(self.parent.file_extensions)}}}",
+                WatchKind.CHANGE | WatchKind.DELETE,
+            )
 
     async def _file_watcher(self, sender: Any, changes: List[FileEvent]) -> None:
         to_change: Dict[str, FileEvent] = {}

robotcode/language_server/common/parts/workspace.py

@@ -159,6 +159,13 @@ def __init__(
         self._file_watchers: weakref.WeakSet[FileWatcherEntry] = weakref.WeakSet()
         self._file_watchers_lock = Lock()
 
+        self.parent.on_shutdown.add(self._on_shutdown)
+
+    @_logger.call
+    async def _on_shutdown(self, sender: Any) -> None:
+        for e in self._file_watchers.copy():
+            await self.remove_file_watcher_entry(e)
+
     def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
         capabilities.workspace = ServerCapabilitiesWorkspace(
             workspace_folders=WorkspaceFoldersServerCapabilities(
@@ -373,6 +380,7 @@ async def add_file_watcher(
     ) -> FileWatcherEntry:
         return await self.add_file_watchers(callback, [(glob_pattern, kind)])
 
+    @_logger.call
     async def add_file_watchers(
         self,
         callback: Callable[[Any, List[FileEvent]], Coroutine[Any, Any, None]],
@@ -430,6 +438,7 @@ def remove() -> None:
 
             return entry
 
+    @_logger.call
     async def remove_file_watcher_entry(self, entry: FileWatcherEntry) -> None:
         async with self._file_watchers_lock:
             self._file_watchers.remove(entry)

robotcode/language_server/common/protocol.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Any, List, Optional, Union, cast
+from typing import Any, List, Optional, Set, Union, cast
 
 from ...jsonrpc2.protocol import (
     JsonRPCErrorException,
@@ -83,6 +83,8 @@ class LanguageServerProtocol(JsonRPCProtocol):
     name: Optional[str] = None
     version: Optional[str] = None
 
+    file_extensions: Set[str] = set()
+
     def __init__(self, server: JsonRPCServer[Any]):
         super().__init__()
         self.server = server

robotcode/language_server/robotframework/protocol.py

@@ -93,6 +93,8 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
     name = "RobotCode"
     version = __version__
 
+    file_extensions = {"robot", "resource", "py"}
+
     def __init__(self, server: "RobotLanguageServer"):
         super().__init__(server)
         self.options = Options()

vscode-client/languageclientsmanger.ts

@@ -96,11 +96,17 @@ export class LanguageClientsManager {
     this.clients.clear();
 
     for (const client of clients) {
-      promises.push(client.stop());
+      promises.push(client.stop().then((_) => global.gc()));
     }
 
     return Promise.all(promises).then(
-      (r) => r.length > 0,
+      (r) => {
+        if (global.gc) {
+          global.gc();
+        }
+
+        return r.length > 0;
+      },
       (reason) => {
         this.outputChannel.appendLine(`can't stop client ${reason}`);
         return true;
@@ -262,8 +268,6 @@ export class LanguageClientsManager {
           error(_error: Error, _message: Message | undefined, _count: number | undefined): ErrorHandlerResult {
             return {
               action: ErrorAction.Continue,
-
-              message: `har ein error ${_error.message}`,
             };
           },
 
@@ -292,6 +296,9 @@ export class LanguageClientsManager {
       result.onDidChangeState((e) => {
         if (e.newState == State.Running) {
           closeHandlerAction = CloseAction.Restart;
+        } else if (e.newState == State.Stopped) {
+          if (this.clients.get(workspaceFolder.uri.toString()) !== result)
+            closeHandlerAction = CloseAction.DoNotRestart;
         }
 
         this._onClientStateChangedEmitter.fire({