update locking mechanism

Author: d-biehl

robotcode/analyzer/__main__.py

@@ -18,7 +18,7 @@
 
 
 async def main() -> None:
-    async for f in iter_files(
+    for f in iter_files(
         Path("c:/develop/robot/robotframework"),
         f"**/*.{{{ROBOT_FILE_EXTENSION[1:]},{RESOURCE_FILE_EXTENSION[1:]}}}",
         ignore_patterns=exclude_patterns,

robotcode/language_server/common/parts/diagnostics.py

@@ -216,19 +216,16 @@ async def on_get_diagnostics_mode(sender, uri: Uri) -> Optional[DiagnosticsMode]
         ...
 
     async def ensure_workspace_loaded(self) -> None:
-        if not self._workspace_loaded:
-            async with self._workspace_load_lock:
-                if not self._workspace_loaded:
-                    if self.workspace_loaded_event.is_set():
-                        return
-
-                    try:
-                        await self.load_workspace_documents(self)
-                    finally:
-                        self._workspace_loaded = True
-                        self.workspace_loaded_event.set()
-                        await self.on_workspace_loaded(self)
-                        await self.force_refresh_all()
+        async with self._workspace_load_lock:
+            if not self._workspace_loaded and not self.workspace_loaded_event.is_set():
+                self._logger.debug("load workspace documents")
+                try:
+                    await self.load_workspace_documents(self)
+                finally:
+                    self._workspace_loaded = True
+                    self.workspace_loaded_event.set()
+                    await self.on_workspace_loaded(self)
+                    await self.force_refresh_all()
 
     async def force_refresh_all(self, refresh: bool = True) -> None:
         for doc in self.parent.documents.documents:
@@ -293,9 +290,12 @@ async def run_workspace_diagnostics(self) -> None:
                 documents = [
                     doc
                     for doc in self.parent.documents.documents
-                    if (data := self.get_diagnostics_data(doc)).force
-                    or doc.version != data.version
-                    or data.task is None
+                    if not doc.opened_in_editor
+                    and (
+                        (data := self.get_diagnostics_data(doc)).force
+                        or doc.version != data.version
+                        or data.task is None
+                    )
                 ]
 
                 if len(documents) == 0:

robotcode/language_server/common/parts/documents.py

@@ -258,7 +258,7 @@ async def _text_document_did_open(self, text_document: TextDocumentItem, *args:
 
                 self._documents[uri] = document
             else:
-                text_changed = document.text != normalized_text
+                text_changed = await document.text() != normalized_text
                 if text_changed:
                     await document.apply_full_change(text_document.version, normalized_text)
 
@@ -326,7 +326,7 @@ async def _text_document_did_save(
             if text is not None:
                 normalized_text = self._normalize_line_endings(text)
 
-                text_changed = document.text != normalized_text
+                text_changed = await document.text() != normalized_text
                 if text_changed:
                     await document.save(None, text)
                     create_sub_task(

robotcode/language_server/common/text_document.py

@@ -3,11 +3,10 @@
 import collections
 import inspect
 import io
-import threading
 import weakref
 from typing import Any, Awaitable, Callable, Dict, List, Optional, TypeVar, Union, cast
 
-from ...utils.async_tools import async_event, create_sub_task
+from ...utils.async_tools import Lock, async_event, create_sub_task
 from ...utils.logging import LoggingDescriptor
 from ...utils.uri import Uri
 from .lsp_types import DocumentUri, Range
@@ -24,7 +23,7 @@ class CacheEntry:
     def __init__(self) -> None:
         self.data: Any = None
         self.has_data: bool = False
-        self.lock = threading.RLock()
+        self.lock = Lock()
 
 
 class TextDocument:
@@ -39,7 +38,7 @@ def __init__(
     ) -> None:
         super().__init__()
 
-        self._lock = threading.RLock()
+        self._lock = Lock()
         self.document_uri = document_uri
         self.uri = Uri(self.document_uri).normalized()
         self.language_id = language_id
@@ -71,9 +70,11 @@ def __repr__(self) -> str:  # pragma: no cover
             f")"
         )
 
-    @property
-    def text(self) -> str:
-        with self._lock:
+    def text_sync(self) -> str:
+        return self._text
+
+    async def text(self) -> str:
+        async with self._lock:
             return self._text
 
     async def save(self, version: Optional[int], text: Optional[str]) -> None:
@@ -87,13 +88,13 @@ async def revert(self, version: Optional[int]) -> bool:
 
     @_logger.call
     async def apply_none_change(self) -> None:
-        with self._lock:
+        async with self._lock:
             self._lines = None
             await self._invalidate_cache()
 
     @_logger.call
     async def apply_full_change(self, version: Optional[int], text: Optional[str], *, save: bool = False) -> None:
-        with self._lock:
+        async with self._lock:
             if version is not None:
                 self._version = version
             if text is not None:
@@ -105,7 +106,7 @@ async def apply_full_change(self, version: Optional[int], text: Optional[str], *
 
     @_logger.call
     async def apply_incremental_change(self, version: Optional[int], range: Range, text: str) -> None:
-        with self._lock:
+        async with self._lock:
             try:
                 if version is not None:
                     self._version = version
@@ -146,10 +147,11 @@ def __get_lines(self) -> List[str]:
         return self._lines
 
     async def get_lines(self) -> List[str]:
-        if self._lines is None:
-            with self._lock:
+        async with self._lock:
+            if self._lines is None:
                 return self.__get_lines()
-        return self._lines
+
+            return self._lines
 
     @async_event
     async def cache_invalidate(sender) -> None:  # NOSONAR
@@ -166,19 +168,19 @@ async def _invalidate_cache(self) -> None:
 
     @_logger.call
     async def invalidate_cache(self) -> None:
-        with self._lock:
+        async with self._lock:
             await self._invalidate_cache()
 
     async def _invalidate_data(self) -> None:
         self._data.clear()
 
     @_logger.call
     async def invalidate_data(self) -> None:
-        with self._lock:
+        async with self._lock:
             await self._invalidate_data()
 
     async def __remove_cache_entry_safe(self, _ref: Any) -> None:
-        with self._lock:
+        async with self._lock:
             if _ref in self._cache:
                 self._cache.pop(_ref)
 
@@ -218,7 +220,7 @@ async def get_cache(
 
         e = self._cache[reference]
 
-        with e.lock:
+        async with e.lock:
             if not e.has_data:
                 e.data = await entry(self, *args, **kwargs)
                 e.has_data = True
@@ -250,5 +252,5 @@ async def _clear(self) -> None:
 
     @_logger.call
     async def clear(self) -> None:
-        with self._lock:
+        async with self._lock:
             await self._clear()

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -240,12 +240,12 @@ async def visit(self, node: ast.AST) -> None:
         finally:
             self.node_stack = self.node_stack[:-1]
 
-    @staticmethod
-    async def get_ignored_lines(document: TextDocument) -> List[int]:
-        return await document.get_cache(Analyzer.__get_ignored_lines)
+    # @staticmethod
+    # async def get_ignored_lines(document: TextDocument) -> List[int]:
+    #     return await document.get_cache(Analyzer.__get_ignored_lines)
 
     @staticmethod
-    async def __get_ignored_lines(document: TextDocument) -> List[int]:
+    async def get_ignored_lines(document: TextDocument) -> List[int]:
         result = []
         lines = await document.get_lines()
         for line_no, line in enumerate(lines):

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -262,14 +262,13 @@ async def is_valid(self) -> bool:
             return self._lib_doc is not None
 
     async def get_libdoc(self) -> LibraryDoc:
-        if self._lib_doc is None:
-            async with self._lock:
-                if self._lib_doc is None:
-                    await self._update()
+        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()
@@ -344,9 +343,8 @@ async def is_valid(self) -> bool:
             return self._document is not None
 
     async def get_document(self) -> TextDocument:
-        if self._document is None:
-            async with self._lock:
-                await self._get_document()
+        async with self._lock:
+            await self._get_document()
 
         assert self._document is not None
 
@@ -368,11 +366,11 @@ 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:
-        if self._lib_doc is None:
-            async with self._lock:
-                if self._lib_doc is None:
-                    self._lib_doc = await (await self._get_namespace()).get_library_doc()
-        return self._lib_doc
+        async with self._lock:
+            if self._lib_doc is None:
+                self._lib_doc = await (await self._get_namespace()).get_library_doc()
+
+            return self._lib_doc
 
 
 @dataclass()
@@ -446,14 +444,13 @@ async def is_valid(self) -> bool:
             return self._lib_doc is not None
 
     async def get_libdoc(self) -> VariablesDoc:
-        if self._lib_doc is None:
-            async with self._lock:
-                if self._lib_doc is None:
-                    await self._update()
+        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
 
 
 class ImportsManager:
@@ -833,12 +830,11 @@ async def _get_libdoc() -> LibraryDoc:
 
         entry_key = _LibrariesEntryKey(source, args)
 
-        if entry_key not in self._libaries:
-            async with self._libaries_lock:
-                if entry_key not in self._libaries:
-                    self._libaries[entry_key] = _LibrariesEntry(
-                        name, args, self, _get_libdoc, ignore_reference=sentinel is None
-                    )
+        async with self._libaries_lock:
+            if entry_key not in self._libaries:
+                self._libaries[entry_key] = _LibrariesEntry(
+                    name, args, self, _get_libdoc, ignore_reference=sentinel is None
+                )
 
         entry = self._libaries[entry_key]
 
@@ -1016,10 +1012,9 @@ async def _get_libdoc() -> VariablesDoc:
 
         entry_key = _VariablesEntryKey(source, args)
 
-        if entry_key not in self._variables:
-            async with self._variables_lock:
-                if entry_key not in self._variables:
-                    self._variables[entry_key] = _VariablesEntry(name, args, self, _get_libdoc)
+        async with self._variables_lock:
+            if entry_key not in self._variables:
+                self._variables[entry_key] = _VariablesEntry(name, args, self, _get_libdoc)
 
         entry = self._variables[entry_key]
 
@@ -1050,11 +1045,10 @@ async def _get_document() -> TextDocument:
 
         entry_key = _ResourcesEntryKey(source)
 
-        if entry_key not in self._resources:
-            async with self._resources_lock:
+        async with self._resources_lock:
 
-                if entry_key not in self._resources:
-                    self._resources[entry_key] = _ResourcesEntry(name, self, _get_document)
+            if entry_key not in self._resources:
+                self._resources[entry_key] = _ResourcesEntry(name, self, _get_document)
 
         entry = self._resources[entry_key]
 

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -1131,7 +1131,9 @@ def find_library(
     )[0]
 
 
-def get_robot_library_html_doc_str(name: str, working_dir: str = ".", base_dir: str = ".") -> str:
+def get_robot_library_html_doc_str(
+    name: str, working_dir: str = ".", base_dir: str = ".", theme: Optional[str] = None
+) -> str:
     from robot.libdocpkg import LibraryDocumentation
     from robot.libdocpkg.htmlwriter import LibdocHtmlWriter
 
@@ -1145,7 +1147,10 @@ def get_robot_library_html_doc_str(name: str, working_dir: str = ".", base_dir:
     robot_libdoc = LibraryDocumentation(name)
     robot_libdoc.convert_docs_to_html()
     with io.StringIO() as output:
-        writer = LibdocHtmlWriter()
+        if get_robot_version() > (6, 0):
+            writer = LibdocHtmlWriter(theme=theme)
+        else:
+            writer = LibdocHtmlWriter()
         writer.write(robot_libdoc, output)
 
         return output.getvalue()