completion of namespaces now uses the document namespace instead the import manager

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -899,9 +899,9 @@ def __init__(
         self.invalidated_callback = invalidated_callback
         self._document = weakref.ref(document) if document is not None else None
         self._libraries: OrderedDict[str, LibraryEntry] = OrderedDict()
-        self._libraries_matchers: Optional[List[KeywordMatcher]] = None
+        self._libraries_matchers: Optional[Dict[KeywordMatcher, LibraryEntry]] = None
         self._resources: OrderedDict[str, ResourceEntry] = OrderedDict()
-        self._resources_matchers: Optional[List[KeywordMatcher]] = None
+        self._resources_matchers: Optional[Dict[KeywordMatcher, ResourceEntry]] = None
         self._variables: OrderedDict[str, VariablesEntry] = OrderedDict()
         self._initialized = False
         self._initialize_lock = asyncio.Lock()
@@ -948,11 +948,11 @@ async def get_libraries(self) -> OrderedDict[str, LibraryEntry]:
 
         return self._libraries
 
-    async def get_libraries_matchers(self) -> List[KeywordMatcher]:
+    async def get_libraries_matchers(self) -> Dict[KeywordMatcher, LibraryEntry]:
         if self._libraries_matchers is None:
-            self._libraries_matchers = [
-                KeywordMatcher(v.alias or v.name or v.import_name) for v in (await self.get_libraries()).values()
-            ]
+            self._libraries_matchers = {
+                KeywordMatcher(v.alias or v.name or v.import_name): v for v in (await self.get_libraries()).values()
+            }
         return self._libraries_matchers
 
     @_logger.call
@@ -961,11 +961,11 @@ async def get_resources(self) -> OrderedDict[str, ResourceEntry]:
 
         return self._resources
 
-    async def get_resources_matchers(self) -> List[KeywordMatcher]:
+    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) for v in (await self.get_resources()).values()
-            ]
+            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
 
     async def get_library_doc(self) -> LibraryDoc:
@@ -1021,6 +1021,7 @@ async def ensure_initialized(self) -> bool:
                                 if e not in new_imports:
                                     new_imports.append(e)
                             self.document.set_data(Namespace, new_imports)
+                            self.document.set_data(Namespace.DataEntry, None)
                         else:
                             data_entry = self.document.get_data(Namespace.DataEntry)
 

robotcode/language_server/robotframework/parts/completion.py

@@ -215,15 +215,15 @@ async def resolve(self, completion_item: CompletionItem) -> CompletionItem:
                         name = completion_item.data.get("name", None)
                         if name is not None:
                             try:
-                                lib_doc = await (
-                                    await self.parent.documents_cache.get_imports_manager(document)
-                                ).get_libdoc_for_library_import(
-                                    name, (), str(document.uri.to_path().parent), sentinel=self
-                                )
+                                entry = (
+                                    await (
+                                        await self.parent.documents_cache.get_namespace(document)
+                                    ).get_libraries_matchers()
+                                ).get(name, None)
 
-                                if lib_doc is not None:
+                                if entry is not None:
                                     completion_item.documentation = MarkupContent(
-                                        kind=MarkupKind.MARKDOWN, value=lib_doc.to_markdown(False)
+                                        kind=MarkupKind.MARKDOWN, value=entry.library_doc.to_markdown(False)
                                     )
 
                             except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
@@ -236,15 +236,15 @@ async def resolve(self, completion_item: CompletionItem) -> CompletionItem:
                         name = completion_item.data.get("name", None)
                         if name is not None:
                             try:
-                                lib_doc = lib_doc = await (
-                                    await self.parent.documents_cache.get_imports_manager(document)
-                                ).get_libdoc_for_resource_import(
-                                    name, str(document.uri.to_path().parent), sentinel=self
-                                )
+                                entry = (
+                                    await (
+                                        await self.parent.documents_cache.get_namespace(document)
+                                    ).get_resources_matchers()
+                                ).get(name, None)
 
-                                if lib_doc is not None:
+                                if entry is not None:
                                     completion_item.documentation = MarkupContent(
-                                        kind=MarkupKind.MARKDOWN, value=lib_doc.to_markdown()
+                                        kind=MarkupKind.MARKDOWN, value=entry.library_doc.to_markdown()
                                     )
 
                             except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):

robotcode/language_server/robotframework/parts/references.py

@@ -304,8 +304,8 @@ async def _find_keyword_references_in_file(
         ):
             return []
 
-        libraries_matchers = await namespace.get_libraries_matchers()
-        resources_matchers = await namespace.get_resources_matchers()
+        libraries_matchers = (await namespace.get_libraries_matchers()).keys()
+        resources_matchers = (await namespace.get_resources_matchers()).keys()
 
         async def _run() -> List[Location]:
             kw_matcher = KeywordMatcher(kw_doc.name)