correct loading and closing documents/library/resources

Author: d-biehl

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to the "robotcode" extension will be documented in this file
 
 ## [Unreleased]
 
+### added
+
+- correct loading and closing documents/library/resources
+
 ##  0.2.4
 
 ### added

robotcode/debugger/protocol.py

@@ -378,13 +378,15 @@ async def handle_response(self, message: Response) -> None:
 
         try:
             if message.success:
-                entry.future.set_result(try_convert_value(message.body, entry.result_type))
+                if not entry.future.done():
+                    entry.future.set_result(try_convert_value(message.body, entry.result_type))
             else:
                 raise DebugAdapterErrorResponseError(ErrorResponse(**message.dict()))
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
-            entry.future.set_exception(e)
+            if not entry.future.done():
+                entry.future.set_exception(e)
 
     @_logger.call
     async def handle_event(self, message: Event) -> None:

robotcode/jsonrpc2/protocol.py

@@ -615,11 +615,13 @@ async def handle_response(self, message: JsonRPCResponse) -> None:
             return
 
         try:
-            entry.future.set_result(try_convert_value(message.result, entry.result_type))
+            if not entry.future.done():
+                entry.future.set_result(try_convert_value(message.result, entry.result_type))
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
-            entry.future.set_exception(e)
+            if not entry.future.done():
+                entry.future.set_exception(e)
 
     @_logger.call
     async def handle_error(self, message: JsonRPCError) -> None:

robotcode/language_server/common/parts/documents.py

@@ -75,27 +75,72 @@ def __iter__(self) -> Iterator[DocumentUri]:
     def __hash__(self) -> int:
         return id(self)
 
-    def _create_document(self, text_document: TextDocumentItem) -> TextDocument:
-        return TextDocument(text_document)
+    def _create_document(
+        self,
+        text_document_item: Optional[TextDocumentItem] = None,
+        *,
+        document_uri: Optional[DocumentUri] = None,
+        language_id: Optional[str] = None,
+        version: Optional[int] = None,
+        text: Optional[str] = None,
+    ) -> TextDocument:
+        return TextDocument(
+            text_document_item=text_document_item,
+            document_uri=document_uri,
+            language_id=language_id,
+            version=version,
+            text=text,
+        )
+
+    def append_document(
+        self,
+        document_uri: DocumentUri,
+        language_id: str,
+        text: Optional[str],
+        version: Optional[int] = None,
+    ) -> TextDocument:
+        document = self._create_document(document_uri=document_uri, language_id=language_id, version=version, text=text)
+
+        self._documents[document_uri] = document
+        return document
 
     @rpc_method(name="textDocument/didOpen", param_type=DidOpenTextDocumentParams)
     @_logger.call
     async def _text_document_did_open(self, text_document: TextDocumentItem, *args: Any, **kwargs: Any) -> None:
-        document = self._create_document(text_document)
+        uri = str(Uri(text_document.uri).normalized())
+        document = self.get(uri, None)
 
-        self._documents[str(Uri(text_document.uri).normalized())] = document
+        if document is None:
+            document = self._create_document(text_document)
 
-        await self.did_open(self, document)
+            self._documents[uri] = document
+            await self.did_open(self, document)
+        else:
+            await document.apply_full_change(text_document.version, text_document.text)
+
+        document.references.add(self)
 
     @rpc_method(name="textDocument/didClose", param_type=DidCloseTextDocumentParams)
     @_logger.call
     async def _text_document_did_close(self, text_document: TextDocumentIdentifier, *args: Any, **kwargs: Any) -> None:
-        document = self._documents.pop(str(Uri(text_document.uri).normalized()), None)
+        uri = str(Uri(text_document.uri).normalized())
+        document = self._documents.get(uri, None)
 
         if document is not None:
+            document.references.remove(self)
+
+            await self.close_document(document)
+
+    async def close_document(self, document: TextDocument) -> None:
+        if len(document.references) == 0:
+            self._documents.pop(str(document.uri), None)
+
             await self.did_close(self, document)
+
             await document.clear()
             del document
+        else:
+            document.version = None
 
         gc.collect()
 

robotcode/language_server/common/text_document.py

@@ -57,6 +57,7 @@ def __init__(
         super().__init__()
 
         self._lock = asyncio.Lock()
+        self._references: weakref.WeakSet[Any] = weakref.WeakSet()
 
         self.document_uri = (
             text_document_item.uri
@@ -86,6 +87,10 @@ def __init__(
 
         self._loop = asyncio.get_event_loop()
 
+    @property
+    def references(self) -> weakref.WeakSet[Any]:
+        return self._references
+
     def __del__(self) -> None:
         self._clear()
 

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -2,7 +2,6 @@
 
 import ast
 import asyncio
-import gc
 import weakref
 from collections import OrderedDict
 from concurrent.futures import ProcessPoolExecutor
@@ -220,13 +219,12 @@ def __init__(
         self,
         name: str,
         parent: ImportsManager,
-        get_document_coroutine: Callable[[], Coroutine[Any, Any, Tuple[TextDocument, bool]]],
+        get_document_coroutine: Callable[[], Coroutine[Any, Any, TextDocument]],
     ) -> None:
         super().__init__()
         self.name = name
         self.parent = parent
         self._get_document_coroutine = get_document_coroutine
-        self._delete_on_validate_document = False
         self.references: weakref.WeakSet[Any] = weakref.WeakSet()
         self.file_watchers: List[FileWatcherEntry] = []
         self._document: Optional[TextDocument] = None
@@ -265,8 +263,16 @@ async def check_file_changed(self, changes: List[FileEvent]) -> Optional[FileCha
 
             return None
 
+    def __close_document(self, document: TextDocument) -> None:
+        asyncio.run_coroutine_threadsafe(self.parent.parent_protocol.documents.close_document(document), self._loop)
+
     async def _update(self) -> None:
-        self._document, self._delete_on_validate_document = await self._get_document_coroutine()
+        self._document = await self._get_document_coroutine()
+
+        for r in self.references:
+            self._document.references.add(r)
+
+            weakref.finalize(r, self.__close_document, self._document)
 
         if self._document.version is None:
             self.file_watchers.append(
@@ -286,12 +292,6 @@ async def _invalidate(self) -> None:
 
         await self._remove_file_watcher()
 
-        if self._delete_on_validate_document:
-            if self._document is not None:
-                await self._document.clear()
-            del self._document
-            gc.collect()
-
         self._document = None
 
     async def _remove_file_watcher(self) -> None:
@@ -376,7 +376,7 @@ async def resource_document_changed(self, sender: Any, document: TextDocument) -
         resource_changed: List[LibraryDoc] = []
 
         async with self._resources_lock:
-            for r_key, r_entry in self._resources.items():
+            for r_entry in self._resources.values():
                 lib_doc: Optional[LibraryDoc] = None
                 try:
                     if not await r_entry.is_valid():
@@ -635,7 +635,7 @@ async def find_file(self, name: str, base_dir: str, file_type: str = "Resource")
     async def _get_entry_for_resource_import(self, name: str, base_dir: str, sentinel: Any = None) -> _ResourcesEntry:
         source = await self.find_file(name, base_dir, "Resource")
 
-        async def _get_document() -> Tuple[TextDocument, bool]:
+        async def _get_document() -> TextDocument:
             from robot.utils import FileReader
 
             self._logger.debug(lambda: f"Load resource {name} from source {source}")
@@ -648,16 +648,18 @@ async def _get_document() -> Tuple[TextDocument, bool]:
                     f"Supported extensions are {', '.join(repr(s) for s in RESOURCE_EXTENSIONS)}."
                 )
 
-            source_uri = DocumentUri(Uri.from_path(source_path))
+            source_uri = DocumentUri(Uri.from_path(source_path).normalized())
 
             result = self.parent_protocol.documents.get(source_uri, None)
             if result is not None:
-                return result, False
+                return result
 
             with FileReader(source_path) as reader:
                 text = str(reader.read())
 
-            return TextDocument(document_uri=source_uri, language_id="robot", version=None, text=text), True
+            return self.parent_protocol.documents.append_document(
+                document_uri=source_uri, language_id="robotframework", text=text
+            )
 
         async with self._resources_lock:
             entry_key = _ResourcesEntryKey(source)

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -408,14 +408,13 @@ def to_markdown(self, add_signature: bool = True, only_doc: bool = True) -> str:
             if any(v for v in self.inits.values() if v.args):
                 result += "\n\n---\n".join(i.to_markdown() for i in self.inits.values())
 
-        if self.doc:
-            if result:
-                result += "\n\n---\n"
-            result += (
-                MarkDownFormatter().format(self.get_full_doc(only_doc))
-                if self.doc_format == DEFAULT_DOC_FORMAT
-                else self.doc
-            )
+        if result:
+            result += "\n\n---\n"
+        result += (
+            MarkDownFormatter().format(self.get_full_doc(only_doc))
+            if self.doc_format == DEFAULT_DOC_FORMAT
+            else self.doc
+        )
 
         return result
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -704,28 +704,27 @@ async def get_library_doc(self) -> LibraryDoc:
     async def _ensure_initialized(self) -> None:
         async with self._initialize_lock:
             if not self._initialzed:
-                try:
-                    imports = await self.get_imports()
-
-                    if self.document is not None:
-
-                        old_imports = self.document.get_data(Namespace)
-                        if old_imports is None:
-                            self.document.set_data(Namespace, imports)
-                        elif old_imports != imports:
-                            new_imports = []
-                            for e in old_imports:
-                                if e in imports:
-                                    new_imports.append(e)
-                            for e in imports:
-                                if e not in new_imports:
-                                    new_imports.append(e)
-                            self.document.set_data(Namespace, new_imports)
-
-                    await self._import_default_libraries()
-                    await self._import_imports(imports, str(Path(self.source).parent), top_level=True)
-                finally:
-                    self._initialzed = True
+                imports = await self.get_imports()
+
+                if self.document is not None:
+
+                    old_imports = self.document.get_data(Namespace)
+                    if old_imports is None:
+                        self.document.set_data(Namespace, imports)
+                    elif old_imports != imports:
+                        new_imports = []
+                        for e in old_imports:
+                            if e in imports:
+                                new_imports.append(e)
+                        for e in imports:
+                            if e not in new_imports:
+                                new_imports.append(e)
+                        self.document.set_data(Namespace, new_imports)
+
+                await self._import_default_libraries()
+                await self._import_imports(imports, str(Path(self.source).parent), top_level=True)
+
+                self._initialzed = True
 
     async def get_imports(self) -> List[Import]:
         if self._imports is None:

robotcode/language_server/robotframework/parts/discovering.py

@@ -61,7 +61,7 @@ def get_document(self, uri: DocumentUri) -> TextDocument:
         with FileReader(Uri(uri).to_path()) as reader:
             text = str(reader.read())
 
-        return TextDocument(document_uri=uri, language_id="robot", version=None, text=text)
+        return TextDocument(document_uri=uri, language_id="robotframework", version=None, text=text)
 
     def get_tests_from_workspace_threading(self, paths: Optional[List[str]]) -> List[TestItem]:
         from robot.output.logger import LOGGER

robotcode/language_server/robotframework/parts/documents_cache.py

@@ -4,7 +4,6 @@
 import asyncio
 import enum
 import io
-import logging
 import weakref
 from typing import (
     TYPE_CHECKING,
@@ -76,8 +75,6 @@ async def get_tokens(
     async def __get_tokens(
         self, document: TextDocument, cancelation_token: Optional[CancelationToken] = None
     ) -> List[Token]:
-        logging.info(f"get tokens {document.uri}")
-
         document_type = await self.get_document_type(document)
         if document_type == DocumentType.INIT:
             return await self.get_init_tokens(document, cancelation_token)