some correction to load libraries/resources with same name. fixes #9

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -923,7 +923,7 @@ def import_test_library(
     ) -> Union[Any, Tuple[Any, str]]:
 
         with OutputCapturer(library_import=True):
-            importer = Importer("test library")
+            importer = Importer("test library", LOGGER)
             return importer.import_class_or_module(name, return_source=True)
 
     def get_test_library(

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -1028,7 +1028,7 @@ async def _import(value: Import) -> Optional[LibraryEntry]:
                     ]
 
                     if not allready_imported_resources and entry.library_doc.source != self.source:
-                        self._resources[entry.alias or entry.name or entry.import_name] = entry
+                        self._resources[entry.import_name] = entry
                         try:
                             await self._import_imports(
                                 entry.imports,
@@ -1060,7 +1060,7 @@ async def _import(value: Import) -> Optional[LibraryEntry]:
                                     )
                                 )
                             elif allready_imported_resources and allready_imported_resources[0].library_doc.source:
-                                self._resources[entry.alias or entry.name or entry.import_name] = entry
+                                self._resources[entry.import_name] = entry
 
                                 self._diagnostics.append(
                                     Diagnostic(
@@ -1130,7 +1130,8 @@ async def _import(value: Import) -> Optional[LibraryEntry]:
                             )
                         )
 
-                    self._libraries[entry.alias or entry.name or entry.import_name] = entry
+                    if (entry.alias or entry.name or entry.import_name) not in self._libraries:
+                        self._libraries[entry.alias or entry.name or entry.import_name] = entry
                 # TODO Variables
 
     async def _import_default_libraries(self) -> None:
@@ -1310,7 +1311,7 @@ async def _yield_owner_and_kw_names(self, full_name: str) -> AsyncIterator[Tuple
     async def _get_explicit_keyword(self, name: str) -> Optional[KeywordDoc]:
         found: List[Tuple[LibraryEntry, KeywordDoc]] = []
         async for owner_name, kw_name in self._yield_owner_and_kw_names(name):
-            found.extend(await self._find_keywords(owner_name, kw_name))
+            found.extend(await self.find_keywords(owner_name, kw_name))
         if len(found) > 1:
             self.diagnostics.append(
                 DiagnosticsEntry(
@@ -1323,13 +1324,13 @@ async def _get_explicit_keyword(self, name: str) -> Optional[KeywordDoc]:
 
         return found[0][1] if found else None
 
-    async def _find_keywords(self, owner_name: str, name: str) -> Sequence[Tuple[LibraryEntry, KeywordDoc]]:
+    async def find_keywords(self, owner_name: str, name: str) -> Sequence[Tuple[LibraryEntry, KeywordDoc]]:
         from robot.utils.match import eq
 
         return [
             (v, v.library_doc.keywords[name])
-            async for k, v in async_chain(self.namespace._libraries.items(), self.namespace._resources.items())
-            if eq(k, owner_name) and name in v.library_doc.keywords
+            async for v in async_chain(self.namespace._libraries.values(), self.namespace._resources.values())
+            if eq(v.alias or v.name, owner_name) and name in v.library_doc.keywords
         ]
 
     def _create_multiple_keywords_found_message(

robotcode/language_server/robotframework/parts/goto.py

@@ -245,26 +245,23 @@ async def definition_LibraryImport(  # noqa: N802
                 if namespace is None:
                     return None
 
-                libdocs = [
-                    entry.library_doc
-                    for entry in (await namespace.get_libraries()).values()
-                    if entry.import_name == library_node.name
-                    and entry.args == library_node.args
-                    and entry.alias == library_node.alias
-                ]
+                try:
+                    libdoc = await namespace.imports_manager.get_libdoc_for_library_import(
+                        library_node.name, library_node.args, str(document.uri.to_path().parent)
+                    )
 
-                if len(libdocs) == 1:
-                    result = libdocs[0]
-                    python_source = result.source_or_origin
+                    python_source = libdoc.source_or_origin
                     if python_source is not None:
                         return [
                             LocationLink(
                                 origin_selection_range=range_from_token_or_node(library_node, name_token),
                                 target_uri=str(Uri.from_path(python_source)),
-                                target_range=result.range,
-                                target_selection_range=result.range,
+                                target_range=libdoc.range,
+                                target_selection_range=libdoc.range,
                             )
                         ]
+                except BaseException:
+                    pass
         return None
 
     async def definition_ResourceImport(  # noqa: N802
@@ -285,22 +282,21 @@ async def definition_ResourceImport(  # noqa: N802
                 if namespace is None:
                     return None
 
-                libdocs = [
-                    entry.library_doc
-                    for entry in (await namespace.get_resources()).values()
-                    if entry.import_name == resource_node.name
-                ]
+                try:
+                    libdoc = await namespace.imports_manager.get_libdoc_for_resource_import(
+                        resource_node.name, str(document.uri.to_path().parent)
+                    )
 
-                if len(libdocs) == 1:
-                    result = libdocs[0]
-                    python_source = result.source_or_origin
+                    python_source = libdoc.source_or_origin
                     if python_source is not None:
                         return [
                             LocationLink(
                                 origin_selection_range=range_from_token_or_node(resource_node, name_token),
                                 target_uri=str(Uri.from_path(python_source)),
-                                target_range=result.range,
-                                target_selection_range=result.range,
+                                target_range=libdoc.range,
+                                target_selection_range=libdoc.range,
                             )
                         ]
+                except BaseException:
+                    pass
         return None

robotcode/language_server/robotframework/parts/hover.py

@@ -213,16 +213,10 @@ async def hover_LibraryImport(  # noqa: N802
                 if namespace is None:
                     return None
 
-                libdocs = [
-                    entry.library_doc
-                    for entry in (await namespace.get_libraries()).values()
-                    if entry.import_name == library_node.name
-                    and entry.args == library_node.args
-                    and entry.alias == library_node.alias
-                ]
-
-                if len(libdocs) == 1:
-                    libdoc = libdocs[0]
+                try:
+                    libdoc = await namespace.imports_manager.get_libdoc_for_library_import(
+                        library_node.name, library_node.args, str(document.uri.to_path().parent)
+                    )
 
                     return Hover(
                         contents=MarkupContent(
@@ -231,6 +225,8 @@ async def hover_LibraryImport(  # noqa: N802
                         ),
                         range=range_from_token_or_node(library_node, name_token),
                     )
+                except BaseException:
+                    pass
         return None
 
     async def hover_ResourceImport(  # noqa: N802
@@ -251,19 +247,17 @@ async def hover_ResourceImport(  # noqa: N802
                 if namespace is None:
                     return None
 
-                libdocs = [
-                    entry.library_doc
-                    for entry in (await namespace.get_resources()).values()
-                    if entry.import_name == resource_node.name
-                ]
-
-                if len(libdocs) == 1:
-                    libdoc = libdocs[0]
+                try:
+                    libdoc = await namespace.imports_manager.get_libdoc_for_resource_import(
+                        resource_node.name, str(document.uri.to_path().parent)
+                    )
                     return Hover(
                         contents=MarkupContent(
                             kind=MarkupKind.MARKDOWN,
                             value=libdoc.to_markdown(),
                         ),
                         range=range_from_token_or_node(resource_node, name_token),
                     )
+                except BaseException:
+                    pass
         return None