implement recognize changes in inter file dependencies

Author: d-biehl

robotcode/jsonrpc2/protocol.py

@@ -592,27 +592,37 @@ async def handle_response(self, message: JsonRPCResponse) -> None:
                 res = None
                 if message.result is not None:
                     res = from_dict(message.result, entry.result_type)
-                if entry.future._loop == asyncio.get_running_loop():
+                if entry.future.get_loop() == asyncio.get_running_loop():
                     entry.future.set_result(res)
                 else:
-                    if entry.future._loop.is_running():
+                    if entry.future.get_loop().is_running():
 
-                        def s(f: asyncio.Future[Any], r: Any) -> None:
-                            if not f.done():
-                                f.set_result(r)
+                        def set_result(f: asyncio.Future[Any], r: Any, ev: threading.Event) -> None:
+                            try:
+                                if not f.done() and f.get_loop().is_running():
+                                    f.set_result(r)
+                            finally:
+                                ev.set()
+
+                        done = threading.Event()
+
+                        entry.future.get_loop().call_soon_threadsafe(set_result, entry.future, res, done)
+
+                        if not done.wait(120):
+                            raise TimeoutError("Can't set response result")
 
-                        entry.future._loop.call_soon_threadsafe(s, entry.future, res)
                     else:
                         self._logger.warning("Response loop is not running.")
 
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
             if not entry.future.done():
-                if entry.future._loop == asyncio.get_running_loop():
+                if entry.future.get_loop() == asyncio.get_running_loop():
                     entry.future.set_exception(e)
                 else:
-                    entry.future._loop.call_soon_threadsafe(entry.future.set_exception, e)
+                    if entry.future.get_loop().is_running():
+                        entry.future.get_loop().call_soon_threadsafe(entry.future.set_exception, e)
 
     @_logger.call
     async def handle_error(self, message: JsonRPCError) -> None:

robotcode/language_server/common/parts/diagnostics.py

@@ -31,6 +31,7 @@
     ErrorCodes,
     PreviousResultId,
     ProgressToken,
+    PublishDiagnosticsParams,
     RelatedFullDocumentDiagnosticReport,
     RelatedUnchangedDocumentDiagnosticReport,
     ServerCapabilities,
@@ -226,15 +227,16 @@ async def ensure_workspace_loaded(self) -> None:
                         await self.on_workspace_loaded(self)
                         await self.force_refresh_all()
 
-    async def force_refresh_all(self) -> None:
+    async def force_refresh_all(self, refresh: bool = True) -> None:
         for doc in self.parent.documents.documents:
             self.get_diagnostics_data(doc).force = True
 
-        await self.refresh()
+        if refresh:
+            await self.refresh()
 
-    async def force_refresh_document(self, document: TextDocument) -> None:
+    async def force_refresh_document(self, document: TextDocument, refresh: bool = True) -> None:
         self.get_diagnostics_data(document).force = True
-        if document.opened_in_editor:
+        if refresh and document.opened_in_editor:
             await self.refresh()
 
     @_logger.call
@@ -262,8 +264,20 @@ async def _get_diagnostics_for_document(self, document: TextDocument, data: Diag
                     if result.diagnostics is not None:
                         collected_keys.append(result.key)
 
-                    if document.opened_in_editor:
-                        await self.refresh()
+                    # if document.opened_in_editor:
+                    #     await self.refresh()
+
+                    if data.entries:
+                        self.parent.send_notification(
+                            "textDocument/publishDiagnostics",
+                            PublishDiagnosticsParams(
+                                uri=document.document_uri,
+                                version=document._version,
+                                diagnostics=[
+                                    e for e in itertools.chain(*(i for i in data.entries.values() if i is not None))
+                                ],
+                            ),
+                        )
 
         except asyncio.CancelledError:
             self._logger.debug(lambda: f"_get_diagnostics cancelled for {document}")
@@ -292,8 +306,7 @@ async def _text_document_diagnostic(
 
                 task = data.task
 
-                data = DiagnosticsData()
-                document.set_data(self, data)
+                data.force = False
 
                 if task is not None and not task.done():
                     self._logger.debug(lambda: f"try to cancel diagnostics for {document}")
@@ -309,23 +322,22 @@ async def _text_document_diagnostic(
                 def done(t: asyncio.Task[Any]) -> None:
 
                     self._logger.debug(lambda: f"diagnostics for {document} {'canceled' if t.cancelled() else 'ended'}")
-                    try:
-                        t.result()
-                    except asyncio.CancelledError:
-                        pass
-                    except (SystemExit, KeyboardInterrupt):
-                        raise
-                    except BaseException as e:
-                        self._logger.exception(e)
+                    if t.done() and not t.cancelled():
+                        ex = t.exception()
+
+                        if ex is None or isinstance(ex, asyncio.CancelledError):
+                            return
 
                 data.task.add_done_callback(done)
 
             if data.id == previous_result_id:
                 return RelatedUnchangedDocumentDiagnosticReport(result_id=data.id)
 
-            return RelatedFullDocumentDiagnosticReport(
-                list(itertools.chain(*(e for e in data.entries.values() if e is not None))), result_id=data.id
-            )
+            # return RelatedFullDocumentDiagnosticReport(
+            #     list(itertools.chain(*(e for e in data.entries.values() if e is not None))), result_id=data.id
+            # )
+
+            return RelatedFullDocumentDiagnosticReport([], result_id=data.id)
         except asyncio.CancelledError:
             self._logger.debug("canceled _text_document_diagnostic")
             raise

robotcode/language_server/common/text_document.py

@@ -6,7 +6,7 @@
 import weakref
 from typing import Any, Awaitable, Callable, Dict, List, Optional, TypeVar, Union, cast
 
-from ...utils.async_tools import Lock, 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
@@ -90,7 +90,7 @@ async def revert(self, version: Optional[int]) -> bool:
     async def apply_none_change(self) -> None:
         async with self._lock:
             self._lines = None
-            self._invalidate_cache()
+            await self._invalidate_cache()
 
     @_logger.call
     async def apply_full_change(self, version: Optional[int], text: Optional[str], *, save: bool = False) -> None:
@@ -102,7 +102,7 @@ async def apply_full_change(self, version: Optional[int], text: Optional[str], *
                 self._lines = None
             if save:
                 self._orig_text = self._text
-            self._invalidate_cache()
+            await self._invalidate_cache()
 
     @_logger.call
     async def apply_incremental_change(self, version: Optional[int], range: Range, text: str) -> None:
@@ -138,7 +138,7 @@ async def apply_incremental_change(self, version: Optional[int], range: Range, t
                     self._text = new_text.getvalue()
             finally:
                 self._lines = None
-                self._invalidate_cache()
+                await self._invalidate_cache()
 
     def __get_lines(self) -> List[str]:
         if self._lines is None:
@@ -152,21 +152,31 @@ async def get_lines(self) -> List[str]:
                 return self.__get_lines()
         return self._lines
 
-    def _invalidate_cache(self) -> None:
+    @async_event
+    async def cache_invalidate(sender) -> None:  # NOSONAR
+        ...
+
+    @async_event
+    async def cache_invalidated(sender) -> None:  # NOSONAR
+        ...
+
+    async def _invalidate_cache(self) -> None:
+        await self.cache_invalidate(self)
         self._cache.clear()
+        await self.cache_invalidated(self)
 
     @_logger.call
     async def invalidate_cache(self) -> None:
         async with self._lock:
-            self._invalidate_cache()
+            await self._invalidate_cache()
 
-    def _invalidate_data(self) -> None:
+    async def _invalidate_data(self) -> None:
         self._data.clear()
 
     @_logger.call
     async def invalidate_data(self) -> None:
         async with self._lock:
-            self._invalidate_data()
+            await self._invalidate_data()
 
     async def __remove_cache_entry_safe(self, _ref: Any) -> None:
         async with self._lock:
@@ -185,6 +195,19 @@ def __get_cache_reference(self, entry: Callable[..., Any], /, *, add_remove: boo
 
         return reference
 
+    def get_cache_value(
+        self,
+        entry: Union[Callable[[TextDocument], Awaitable[_T]], Callable[..., Awaitable[_T]]],
+    ) -> Optional[_T]:
+
+        reference = self.__get_cache_reference(entry)
+
+        e = self._cache.get(reference, None)
+        if e is None:
+            return None
+
+        return cast(Optional[_T], e.data)
+
     async def get_cache(
         self,
         entry: Union[Callable[[TextDocument], Awaitable[_T]], Callable[..., Awaitable[_T]]],
@@ -216,12 +239,12 @@ def set_data(self, key: Any, data: Any) -> None:
     def get_data(self, key: Any, default: Optional[_T] = None) -> _T:
         return self._data.get(key, default)
 
-    def _clear(self) -> None:
+    async def _clear(self) -> None:
         self._lines = None
-        self._invalidate_cache()
-        self._invalidate_data()
+        await self._invalidate_cache()
+        await self._invalidate_data()
 
     @_logger.call
     async def clear(self) -> None:
         async with self._lock:
-            self._clear()
+            await self._clear()

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -14,7 +14,6 @@
 from typing import (
     Any,
     AsyncGenerator,
-    Callable,
     Dict,
     Iterable,
     List,
@@ -28,7 +27,7 @@
 )
 
 from ....utils.async_itertools import as_async_iterable
-from ....utils.async_tools import Lock
+from ....utils.async_tools import Lock, async_event
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
 from ...common.lsp_types import (
@@ -130,6 +129,11 @@ async def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
             if name.endswith("="):
                 name = name[:-1].rstrip()
 
+            has_value = bool(variable.value)
+            value = tuple(
+                s.replace("${CURDIR}", str(Path(self.source).parent).replace("\\", "\\\\")) for s in variable.value
+            )
+
             self._results.append(
                 VariableDefinition(
                     name=variable.name,
@@ -141,9 +145,9 @@ async def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
                     end_line_no=variable.lineno,
                     end_col_offset=variable.end_col_offset,
                     source=self.source,
-                    has_value=bool(variable.value),
+                    has_value=has_value,
                     resolvable=True,
-                    value=variable.value,
+                    value=value,
                 )
             )
 
@@ -546,7 +550,6 @@ def __init__(
         imports_manager: ImportsManager,
         model: ast.AST,
         source: str,
-        invalidated_callback: Callable[[Namespace], None],
         document: Optional[TextDocument] = None,
         document_type: Optional[DocumentType] = None,
         languages: Optional[Languages] = None,
@@ -557,7 +560,6 @@ def __init__(
 
         self.model = model
         self.source = source
-        self.invalidated_callback = invalidated_callback
         self._document = weakref.ref(document) if document is not None else None
         self.document_type: Optional[DocumentType] = document_type
         self.languages = languages
@@ -598,6 +600,22 @@ def __init__(
         self.imports_manager.resources_changed.add(self.resources_changed)
         self.imports_manager.variables_changed.add(self.variables_changed)
 
+    @async_event
+    async def has_invalidated(sender) -> None:  # NOSONAR
+        ...
+
+    @async_event
+    async def has_initialized(sender) -> None:  # NOSONAR
+        ...
+
+    @async_event
+    async def has_imports_changed(sender) -> None:  # NOSONAR
+        ...
+
+    @async_event
+    async def has_analysed(sender) -> None:  # NOSONAR
+        ...
+
     @property
     def document(self) -> Optional[TextDocument]:
         return self._document() if self._document is not None else None
@@ -663,7 +681,7 @@ async def invalidate(self) -> None:
 
             await self._reset_global_variables()
 
-        self.invalidated_callback(self)
+        await self.has_invalidated(self)
 
     @_logger.call
     async def get_diagnostisc(self) -> List[Diagnostic]:
@@ -744,7 +762,9 @@ class DataEntry(NamedTuple):
 
     @_logger.call(condition=lambda self: not self._initialized)
     async def ensure_initialized(self) -> bool:
+
         if not self._initialized:
+            imports_changed = False
             async with self._initialize_lock:
                 if not self._initialized:
                     try:
@@ -760,6 +780,8 @@ async def ensure_initialized(self) -> bool:
                             if old_imports is None:
                                 self.document.set_data(Namespace, imports)
                             elif old_imports != imports:
+                                imports_changed = True
+
                                 new_imports = []
                                 for e in old_imports:
                                     if e in imports:
@@ -801,12 +823,19 @@ async def ensure_initialized(self) -> bool:
                         await self._reset_global_variables()
 
                         self._initialized = True
+
                     except BaseException as e:
                         if not isinstance(e, asyncio.CancelledError):
                             self._logger.exception(e, level=logging.DEBUG)
                         await self.invalidate()
                         raise
 
+            if self._initialized:
+                await self.has_initialized(self)
+
+                if imports_changed:
+                    await self.has_imports_changed(self)
+
         return self._initialized
 
     @property
@@ -1532,6 +1561,7 @@ async def _analyze(self) -> None:
                                     source=DIAGNOSTICS_SOURCE_NAME,
                                     code=err.type_name,
                                 )
+
                     except asyncio.CancelledError:
                         canceled = True
                         self._logger.debug("analyzing canceled")
@@ -1545,6 +1575,8 @@ async def _analyze(self) -> None:
                             else f"end analyzed {self.document} failed in {time.monotonic() - start_time}s"
                         )
 
+            await self.has_analysed(self)
+
     async def get_finder(self) -> KeywordFinder:
         if self._finder is None:
             await self.ensure_initialized()