add callback_filter to async_event, watch files for changes if files are not opened from editor

Author: d-biehl

log.ini

@@ -1,6 +1,7 @@
 [loggers]
 #keys: root,server,language_server,language_server_parts,jsonrpc2,jsonrpc2_message,robotframework,debugger, debugger_launcher, asyncio
-keys: root,robotframework,language_server,language_server_parts
+keys: root,server,language_server,language_server_parts,robotframework,debugger, debugger_launcher, asyncio
+#keys: root,server,robotframework,language_server,language_server_parts
 
 [formatters]
 keys: detailed,simple,colored_simple

robotcode/language_server/common/parts/diagnostics.py

@@ -8,7 +8,7 @@
 from ....utils.async_event import async_tasking_event_iterator
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
-from ..language import HasLanguageId
+from ..language import HasLanguageId, language_id
 from ..lsp_types import Diagnostic, DocumentUri, PublishDiagnosticsParams
 from ..text_document import TextDocument
 
@@ -141,14 +141,17 @@ def _cancel_entry(self, entry: Optional[PublishDiagnosticsEntry]) -> None:
 
         entry.cancel()
 
+    @language_id("robotframework")
     @_logger.call
     async def on_did_open(self, sender: Any, document: TextDocument) -> None:
         await 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)
 
+    @language_id("robotframework")
     @_logger.call
     async def on_did_close(self, sender: Any, document: TextDocument) -> None:
         async with self._task_lock:

robotcode/language_server/common/parts/documents.py

@@ -7,6 +7,7 @@
 from ....utils.async_event import async_event
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
+from ..language import HasLanguageId
 from ..lsp_types import (
     DidChangeTextDocumentParams,
     DidCloseTextDocumentParams,
@@ -56,17 +57,20 @@ async def _protocol_initialized(self, sender: Any) -> None:
     async def _update_filewatchers(self) -> None:
         await self.parent.workspace.add_file_watcher(self._file_watcher, "**/*", WatchKind.CHANGE | WatchKind.DELETE)
 
-    @_logger.call
     async def _file_watcher(self, sender: Any, changes: List[FileEvent]) -> None:
-        self._logger.debug(f"filewatcher {changes}")
         to_change: Dict[str, FileEvent] = {}
         for change in changes:
             to_change[change.uri] = change
 
         for change in to_change.values():
             document = self._documents.get(DocumentUri(Uri(change.uri).normalized()), None)
             if document is not None and not document.opened_in_editor:
-                await self.did_close(self, document)
+                await self.did_close(
+                    self,
+                    document,
+                    callback_filter=lambda c: not isinstance(c, HasLanguageId)
+                    or c.__language_id__ == document.language_id,
+                )
                 await self.close_document(document, True)
 
     @async_event
@@ -142,7 +146,11 @@ async def _text_document_did_open(self, text_document: TextDocumentItem, *args:
         document.opened_in_editor = True
         document.references.add(self)
 
-        await self.did_open(self, document)
+        await self.did_open(
+            self,
+            document,
+            callback_filter=lambda c: not isinstance(c, HasLanguageId) or c.__language_id__ == document.language_id,
+        )
 
     @rpc_method(name="textDocument/didClose", param_type=DidCloseTextDocumentParams)
     @_logger.call
@@ -153,7 +161,11 @@ async def _text_document_did_close(self, text_document: TextDocumentIdentifier,
         if document is not None:
             document.references.remove(self)
             document.opened_in_editor = False
-            await self.did_close(self, document)
+            await self.did_close(
+                self,
+                document,
+                callback_filter=lambda c: not isinstance(c, HasLanguageId) or c.__language_id__ == document.language_id,
+            )
             await self.close_document(document)
 
     @_logger.call
@@ -186,7 +198,11 @@ async def _text_document_did_save(
         if document is not None and text is not None:
             await document.apply_full_change(None, text)
 
-            await self.did_save(self, document)
+            await self.did_save(
+                self,
+                document,
+                callback_filter=lambda c: not isinstance(c, HasLanguageId) or c.__language_id__ == document.language_id,
+            )
 
     @rpc_method(name="textDocument/willSaveWaitUntil", param_type=WillSaveTextDocumentParams)
     @_logger.call
@@ -236,4 +252,8 @@ async def _text_document_did_change(
                     f"for document {text_document.uri}."
                 )
 
-        await self.did_change(self, document)
+        await self.did_change(
+            self,
+            document,
+            callback_filter=lambda c: not isinstance(c, HasLanguageId) or c.__language_id__ == document.language_id,
+        )

robotcode/language_server/common/parts/workspace.py

@@ -355,9 +355,10 @@ async def did_change_watched_files(sender, changes: List[FileEvent]) -> None:
         ...
 
     @rpc_method(name="workspace/didChangeWatchedFiles", param_type=DidChangeWatchedFilesParams)
-    @_logger.call
     async def _workspace_did_change_watched_files(self, changes: List[FileEvent], *args: Any, **kwargs: Any) -> None:
-        await self.did_change_watched_files(self, changes)
+        changes = [e for e in changes if not e.uri.endswith("/globalStorage")]
+        if changes:
+            await self.did_change_watched_files(self, changes)
 
     async def add_file_watcher(
         self,

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -13,6 +13,7 @@
 from ....utils.logging import LoggingDescriptor
 from ....utils.path import path_is_relative_to
 from ....utils.uri import Uri
+from ...common.language import language_id
 from ...common.lsp_types import FileChangeType, FileEvent
 from ...common.parts.workspace import FileWatcherEntry
 from ...common.text_document import TextDocument
@@ -197,13 +198,14 @@ async def is_valid(self) -> bool:
             return self._lib_doc is not None
 
     async def get_libdoc(self) -> LibraryDoc:
-        async with self._lock:
-            if self._lib_doc is None:
-                await self._update()
+        if self._lib_doc is None:
+            async with self._lock:
+                if self._lib_doc is None:
+                    await self._update()
 
-            assert self._lib_doc is not None
+                assert self._lib_doc is not None
 
-            return self._lib_doc
+        return self._lib_doc
 
 
 @dataclass()
@@ -230,6 +232,7 @@ def __init__(
         self._document: Optional[TextDocument] = None
         self._lock = asyncio.Lock()
         self._loop = asyncio.get_event_loop()
+        self._lib_doc: Optional[LibraryDoc] = None
 
     def __del__(self) -> None:
         if self._loop.is_running():
@@ -296,6 +299,7 @@ async def _invalidate(self) -> None:
         await self._remove_file_watcher()
 
         self._document = None
+        self._lib_doc = None
 
     async def _remove_file_watcher(self) -> None:
         if self.file_watchers is not None:
@@ -308,21 +312,28 @@ async def is_valid(self) -> bool:
             return self._document is not None
 
     async def get_document(self) -> TextDocument:
-        async with self._lock:
-            if self._document is None:
-                await self._update()
+        if self._document is None:
+            async with self._lock:
+                if self._document is None:
+                    await self._update()
 
-            assert self._document is not None
+                assert self._document is not None
 
-            return self._document
+        return self._document
 
     async def get_namespace(self) -> Namespace:
         return await self.parent.parent_protocol.documents_cache.get_resource_namespace(await self.get_document())
 
     async def get_libdoc(self) -> LibraryDoc:
-        return await (
-            await self.parent.parent_protocol.documents_cache.get_resource_namespace(await self.get_document())
-        ).get_library_doc()
+        if self._lib_doc is None:
+            async with self._lock:
+                if self._lib_doc is None:
+                    self._lib_doc = await (
+                        await self.parent.parent_protocol.documents_cache.get_resource_namespace(
+                            await self.get_document()
+                        )
+                    ).get_library_doc()
+        return self._lib_doc
 
 
 def _shutdown_process_pool(pool: ProcessPoolExecutor) -> None:
@@ -375,6 +386,7 @@ async def libraries_changed(sender, libraries: List[LibraryDoc]) -> None:
     async def resources_changed(sender, resources: List[LibraryDoc]) -> None:
         ...
 
+    @language_id("robotframework")
     async def resource_document_changed(self, sender: Any, document: TextDocument) -> None:
         resource_changed: List[LibraryDoc] = []
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -478,6 +478,7 @@ async def get(self, model: ast.AST, namespace: Namespace) -> List[Diagnostic]:
         self._namespace = namespace
 
         self.current_testcase_or_keyword_name: Optional[str] = None
+        self.finder = KeywordFinder(self._namespace)
 
         await self.visit(model)
         return self._results
@@ -492,11 +493,9 @@ async def _analyze_keyword_call(
     ) -> Optional[KeywordDoc]:
         result: Optional[KeywordDoc] = None
         try:
-            finder = KeywordFinder(self._namespace)
+            result = await self.finder.find_keyword(keyword)
 
-            result = await finder.find_keyword(keyword)
-
-            for e in finder.diagnostics:
+            for e in self.finder.diagnostics:
                 self._results.append(
                     Diagnostic(
                         range=range_from_token_or_node(value, keyword_token),
@@ -926,6 +925,7 @@ def __init__(
     def document(self) -> Optional[TextDocument]:
         return self._document() if self._document is not None else None
 
+    @_logger.call
     async def libraries_changed(self, sender: Any, libraries: List[LibraryDoc]) -> None:
         for p in libraries:
             if any(e for e in self._libraries.values() if e.library_doc == p):
@@ -934,6 +934,7 @@ async def libraries_changed(self, sender: Any, libraries: List[LibraryDoc]) -> N
                 self.invalidated_callback(self)
                 break
 
+    @_logger.call
     async def resources_changed(self, sender: Any, resources: List[LibraryDoc]) -> None:
         for p in resources:
             if any(e for e in self._resources.values() if e.library_doc.source == p.source):
@@ -956,6 +957,7 @@ async def get_libraries(self) -> OrderedDict[str, LibraryEntry]:
 
         return self._libraries
 
+    @_logger.call
     async def get_libraries_matchers(self) -> Dict[KeywordMatcher, LibraryEntry]:
         if self._libraries_matchers is None:
             self._libraries_matchers = {
@@ -969,13 +971,15 @@ async def get_resources(self) -> OrderedDict[str, ResourceEntry]:
 
         return self._resources
 
+    @_logger.call
     async def get_resources_matchers(self) -> Dict[KeywordMatcher, ResourceEntry]:
         if self._resources_matchers is None:
             self._resources_matchers = {
                 KeywordMatcher(v.alias or v.name or v.import_name): v for v in (await self.get_resources()).values()
             }
         return self._resources_matchers
 
+    @_logger.call
     async def get_library_doc(self) -> LibraryDoc:
         if self._library_doc is None:
             async with self._library_doc_lock:
@@ -1049,12 +1053,14 @@ async def ensure_initialized(self) -> bool:
     def initialized(self) -> bool:
         return self._initialized
 
+    @_logger.call
     async def get_imports(self) -> List[Import]:
         if self._imports is None:
             self._imports = await ImportVisitor().get(self.source, self.model)
 
         return self._imports
 
+    @_logger.call
     async def get_own_variables(self) -> List[VariableDefinition]:
         if self._own_variables is None:
             self._own_variables = await VariablesVisitor().get(self.source, self.model)
@@ -1070,6 +1076,7 @@ def get_builtin_variables(cls) -> List[BuiltInVariableDefinition]:
 
         return cls._builtin_variables
 
+    @_logger.call
     def get_command_line_variables(self) -> List[VariableDefinition]:
         if self.imports_manager.config is None:
             return []
@@ -1079,6 +1086,7 @@ def get_command_line_variables(self) -> List[VariableDefinition]:
             for k in self.imports_manager.config.variables.keys()
         ]
 
+    @_logger.call
     async def get_variables(
         self, nodes: Optional[List[ast.AST]] = None, position: Optional[Position] = None
     ) -> Dict[VariableMatcher, VariableDefinition]:
@@ -1104,11 +1112,13 @@ async def get_variables(
 
         return result
 
+    @_logger.call
     async def find_variable(
         self, name: str, nodes: Optional[List[ast.AST]], position: Optional[Position] = None
     ) -> Optional[VariableDefinition]:
         return (await self.get_variables(nodes, position)).get(VariableMatcher(name), None)
 
+    @_logger.call
     async def _import_imports(self, imports: Iterable[Import], base_dir: str, *, top_level: bool = False) -> None:
         async def _import(value: Import) -> Optional[LibraryEntry]:
             result: Optional[LibraryEntry] = None
@@ -1396,6 +1406,7 @@ async def _import_lib(library: str) -> Optional[LibraryEntry]:
             if e is not None:
                 self._libraries[e.alias or e.name or e.import_name] = e
 
+    @_logger.call
     async def _get_library_entry(
         self,
         name: str,
@@ -1412,6 +1423,7 @@ async def _get_library_entry(
 
         return LibraryEntry(name=library.name, import_name=name, library_doc=library, args=args, alias=alias)
 
+    @_logger.call
     async def _get_resource_entry(self, name: str, base_dir: str, sentinel: Any = None) -> ResourceEntry:
         namespace = await self.imports_manager.get_namespace_for_resource_import(name, base_dir, sentinel=sentinel)
         library_doc = await self.imports_manager.get_libdoc_for_resource_import(name, base_dir, sentinel=sentinel)
@@ -1451,6 +1463,9 @@ async def _analyze(self) -> None:
             async with self._analyze_lock:
                 if not self._analyzed:
                     try:
+                        # self._diagnostics += await asyncio.get_running_loop().run_in_executor(
+                        #     None, asyncio.run, Analyzer().get(self.model, self)
+                        # )
                         self._diagnostics += await Analyzer().get(self.model, self)
 
                         lib_doc = await self.get_library_doc()
@@ -1478,6 +1493,7 @@ async def _analyze(self) -> None:
                     finally:
                         self._analyzed = True
 
+    @_logger.call
     async def find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
         await self.ensure_initialized()
 
@@ -1499,9 +1515,15 @@ def __init__(self, namespace: Namespace) -> None:
         super().__init__()
         self.namespace = namespace
         self.diagnostics: List[DiagnosticsEntry] = []
+        self.self_library_doc: Optional[LibraryDoc] = None
+
+    def reset_diagnostics(self) -> None:
+        self.diagnostics = []
 
     async def find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
         try:
+            self.reset_diagnostics()
+
             result = await self._find_keyword(name)
             if result is None:
                 self.diagnostics.append(
@@ -1539,7 +1561,9 @@ 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)
+        if self.self_library_doc is None:
+            self.self_library_doc = await self.namespace.get_library_doc()
+        return self.self_library_doc.keywords.get(name, None)
 
     async def _yield_owner_and_kw_names(self, full_name: str) -> AsyncIterator[Tuple[str, ...]]:
         tokens = full_name.split(".")

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -33,6 +33,7 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         parent.documents.did_open.add(self.namespace_invalidated)
         parent.documents_cache.namespace_invalidated.add(self.namespace_invalidated)
 
+    @language_id("robotframework")
     async def namespace_invalidated(self, sender: Any, document: TextDocument) -> None:
         await self.parent.diagnostics.start_publish_diagnostics_task(document)