fix(langserver): correct handling of imports with the same namespace name

hover, semantic hightlightning, references are aware of the current keyword call namespace if given

Author: d-biehl

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -25,7 +25,6 @@
     Statement,
     Token,
     is_not_variable_token,
-    iter_over_keyword_names_and_owners,
     range_from_node,
     range_from_node_or_token,
     range_from_token,
@@ -40,13 +39,12 @@
     EnvironmentVariableDefinition,
     LibraryEntry,
     LocalVariableDefinition,
-    ResourceEntry,
     VariableDefinition,
     VariableDefinitionType,
     VariableNotFoundDefinition,
 )
 from .errors import DIAGNOSTICS_SOURCE_NAME, Error
-from .library_doc import KeywordDoc, KeywordMatcher, is_embedded_keyword
+from .library_doc import KeywordDoc, is_embedded_keyword
 from .model_helper import ModelHelperMixin
 from .namespace import (
     KeywordFinder,
@@ -70,8 +68,6 @@ def __init__(
         namespace: Namespace,
         finder: KeywordFinder,
         ignored_lines: List[int],
-        libraries_matchers: Dict[KeywordMatcher, LibraryEntry],
-        resources_matchers: Dict[KeywordMatcher, ResourceEntry],
     ) -> None:
         from robot.parsing.model.statements import Template, TestTemplate
 
@@ -81,8 +77,6 @@ def __init__(
         self.namespace = namespace
         self.finder = finder
         self._ignored_lines = ignored_lines
-        self.libraries_matchers = libraries_matchers
-        self.resources_matchers = resources_matchers
 
         self.current_testcase_or_keyword_name: Optional[str] = None
         self.test_template: Optional[TestTemplate] = None
@@ -404,26 +398,16 @@ async def _analyze_keyword_call(
             result = self.finder.find_keyword(keyword, raise_keyword_error=False)
 
             if keyword is not None:
-                for lib, name in iter_over_keyword_names_and_owners(keyword):
-                    if (
-                        lib is not None
-                        and not any(k for k in self.libraries_matchers.keys() if k == lib)
-                        and not any(k for k in self.resources_matchers.keys() if k == lib)
-                    ):
-                        continue
-
-                    lib_entry, kw_namespace = await self.get_namespace_info_from_keyword(
-                        self.namespace, keyword_token, self.libraries_matchers, self.resources_matchers
-                    )
-                    if lib_entry and kw_namespace:
-                        r = range_from_token(keyword_token)
-                        lib_range = r
-                        r.end.character = r.start.character + len(kw_namespace)
-                        kw_range.start.character = r.end.character + 1
-                        lib_range.end.character = kw_range.start.character - 1
+                lib_entry, kw_namespace = await self.get_namespace_info_from_keyword_token(
+                    self.namespace, keyword_token
+                )
 
-                        if result is not None and result.parent == lib_entry.library_doc:
-                            break
+                if lib_entry and kw_namespace:
+                    r = range_from_token(keyword_token)
+                    lib_range = r
+                    r.end.character = r.start.character + len(kw_namespace)
+                    kw_range.start.character = r.end.character + 1
+                    lib_range.end.character = kw_range.start.character - 1
 
             if (
                 result is not None
@@ -437,7 +421,14 @@ async def _analyze_keyword_call(
 
             if kw_namespace and lib_entry is not None and lib_range is not None:
                 if self.namespace.document is not None:
-                    self._namespace_references[lib_entry].add(Location(self.namespace.document.document_uri, lib_range))
+                    entries = [lib_entry]
+                    if self.finder.multiple_keywords_result is not None:
+                        entries = next(
+                            (v for k, v in (await self.namespace.get_namespaces()).items() if k == kw_namespace),
+                            entries,
+                        )
+                    for entry in entries:
+                        self._namespace_references[entry].add(Location(self.namespace.document.document_uri, lib_range))
 
             if not ignore_errors_if_contains_variables or is_not_variable_token(keyword_token):
                 for e in self.finder.diagnostics:

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -185,6 +185,9 @@ def embedded_arguments(self) -> Any:
 
     def __eq__(self, o: Any) -> bool:
         if isinstance(o, KeywordMatcher):
+            if self._is_namespace != o._is_namespace:
+                return False
+
             if not self.embedded_arguments:
                 return self.normalized_name == o.normalized_name
 
@@ -206,7 +209,7 @@ def __hash__(self) -> int:
         return hash(
             (self.embedded_arguments.name, tuple(self.embedded_arguments.args))
             if self.embedded_arguments
-            else (self.normalized_name,)
+            else (self.normalized_name, self._is_namespace),
         )
 
     def __str__(self) -> str:

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/model_helper.py

@@ -8,7 +8,6 @@
 from typing import (
     Any,
     AsyncIterator,
-    Dict,
     Iterator,
     List,
     Optional,
@@ -21,15 +20,13 @@
 from robotcode.core.lsp.types import Position
 from robotcode.language_server.robotframework.diagnostics.entities import (
     LibraryEntry,
-    ResourceEntry,
     VariableDefinition,
     VariableNotFoundDefinition,
 )
 from robotcode.language_server.robotframework.diagnostics.library_doc import (
     ArgumentInfo,
     KeywordArgumentKind,
     KeywordDoc,
-    KeywordMatcher,
     LibraryDoc,
 )
 from robotcode.language_server.robotframework.diagnostics.namespace import (
@@ -214,32 +211,24 @@ async def get_keyworddoc_and_token_from_position(
 
         return None
 
-    async def get_namespace_info_from_keyword(
-        self,
-        namespace: Namespace,
-        keyword_token: Token,
-        libraries_matchers: Optional[Dict[KeywordMatcher, LibraryEntry]] = None,
-        resources_matchers: Optional[Dict[KeywordMatcher, ResourceEntry]] = None,
+    @classmethod
+    async def get_namespace_info_from_keyword_token(
+        cls, namespace: Namespace, keyword_token: Token
     ) -> Tuple[Optional[LibraryEntry], Optional[str]]:
         lib_entry: Optional[LibraryEntry] = None
-
         kw_namespace: Optional[str] = None
 
-        if libraries_matchers is None:
-            libraries_matchers = await namespace.get_libraries_matchers()
-        if resources_matchers is None:
-            resources_matchers = await namespace.get_resources_matchers()
-
-        for lib, _ in iter_over_keyword_names_and_owners(keyword_token.value):
+        for lib, keyword in iter_over_keyword_names_and_owners(keyword_token.value):
             if lib is not None:
-                lib_entry = next((v for k, v in libraries_matchers.items() if k == lib), None)
-                if lib_entry is not None:
-                    kw_namespace = lib
-                    break
-                lib_entry = next((v for k, v in resources_matchers.items() if k == lib), None)
-                if lib_entry is not None:
+                lib_entries = next((v for k, v in (await namespace.get_namespaces()).items() if k == lib), None)
+                if lib_entries is not None:
                     kw_namespace = lib
+                    lib_entry = next(
+                        (v for v in lib_entries if keyword in v.library_doc.keywords),
+                        lib_entries[0] if lib_entries else None,
+                    )
                     break
+
         return lib_entry, kw_namespace
 
     __match_extended = re.compile(

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -8,7 +8,7 @@
 import re
 import time
 import weakref
-from collections import OrderedDict
+from collections import OrderedDict, defaultdict
 from itertools import chain
 from pathlib import Path
 from typing import (
@@ -539,6 +539,7 @@ def __init__(
         self.workspace_languages = workspace_languages
 
         self._libraries: OrderedDict[str, LibraryEntry] = OrderedDict()
+        self._namespaces: Optional[Dict[KeywordMatcher, List[LibraryEntry]]] = None
         self._libraries_matchers: Optional[Dict[KeywordMatcher, LibraryEntry]] = None
         self._resources: OrderedDict[str, ResourceEntry] = OrderedDict()
         self._resources_matchers: Optional[Dict[KeywordMatcher, ResourceEntry]] = None
@@ -662,6 +663,7 @@ async def is_initialized(self) -> bool:
     async def _invalidate(self) -> None:
         self._initialized = False
 
+        self._namespaces = None
         self._libraries = OrderedDict()
         self._libraries_matchers = None
         self._resources = OrderedDict()
@@ -732,33 +734,26 @@ async def get_import_entries(self) -> OrderedDict[Import, LibraryEntry]:
 
         return self._import_entries
 
-    @_logger.call
     async def get_libraries(self) -> OrderedDict[str, LibraryEntry]:
         await self.ensure_initialized()
 
         return self._libraries
 
-    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, is_namespace=True): v
-                for v in (await self.get_libraries()).values()
-            }
-        return self._libraries_matchers
+    async def get_namespaces(self) -> Dict[KeywordMatcher, List[LibraryEntry]]:
+        if self._namespaces is None:
+            self._namespaces = defaultdict(list)
+
+            for v in (await self.get_libraries()).values():
+                self._namespaces[KeywordMatcher(v.alias or v.name or v.import_name, is_namespace=True)].append(v)
+            for v in (await self.get_resources()).values():
+                self._namespaces[KeywordMatcher(v.alias or v.name or v.import_name, is_namespace=True)].append(v)
+        return self._namespaces
 
     async def get_resources(self) -> OrderedDict[str, ResourceEntry]:
         await self.ensure_initialized()
 
         return self._resources
 
-    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, is_namespace=True): v
-                for v in (await self.get_resources()).values()
-            }
-        return self._resources_matchers
-
     async def get_imported_variables(self) -> OrderedDict[str, VariablesEntry]:
         await self.ensure_initialized()
 
@@ -1579,8 +1574,6 @@ async def _analyze(self) -> None:
                         self,
                         await self.create_finder(),
                         self.get_ignored_lines(self.document) if self.document is not None else [],
-                        await self.get_libraries_matchers(),
-                        await self.get_resources_matchers(),
                     ).run()
 
                     self._diagnostics += result.diagnostics

packages/language_server/src/robotcode/language_server/robotframework/parts/code_action_quick_fixes.py

@@ -147,7 +147,7 @@ async def code_action_create_keyword(
                     if bdd_token is not None and token is not None:
                         keyword_token = token
 
-                    lib_entry, kw_namespace = await self.get_namespace_info_from_keyword(namespace, keyword_token)
+                    lib_entry, kw_namespace = await self.get_namespace_info_from_keyword_token(namespace, keyword_token)
 
                     if lib_entry is not None and lib_entry.library_doc.type == "LIBRARY":
                         disabled = CodeActionDisabledType("Keyword is from a library")
@@ -208,7 +208,7 @@ async def resolve_code_action_create_keyword(
             if bdd_token is not None and token is not None:
                 keyword_token = token
 
-            lib_entry, kw_namespace = await self.get_namespace_info_from_keyword(namespace, keyword_token)
+            lib_entry, kw_namespace = await self.get_namespace_info_from_keyword_token(namespace, keyword_token)
 
             if lib_entry is not None and lib_entry.library_doc.type == "LIBRARY":
                 return None

packages/language_server/src/robotcode/language_server/robotframework/parts/inlay_hint.py

@@ -172,7 +172,7 @@ async def _get_inlay_hint(
                     )
 
         if keyword_token is not None and config.namespaces:
-            lib_entry, kw_namespace = await self.get_namespace_info_from_keyword(namespace, keyword_token)
+            lib_entry, kw_namespace = await self.get_namespace_info_from_keyword_token(namespace, keyword_token)
             if lib_entry is None and kw_namespace is None:
                 if kw_doc.libtype == "LIBRARY":
                     lib = next(

packages/language_server/src/robotcode/language_server/robotframework/parts/rename.py

@@ -337,7 +337,7 @@ async def _find_KeywordCall(  # noqa: N802
             ):
                 keyword_token = self.strip_bdd_prefix(namespace, keyword_token)
 
-            lib_entry, kw_namespace = await self.get_namespace_info_from_keyword(namespace, keyword_token)
+            lib_entry, kw_namespace = await self.get_namespace_info_from_keyword_token(namespace, keyword_token)
 
             kw_range = range_from_token(keyword_token)
 
@@ -451,7 +451,7 @@ async def _find_Fixture(  # noqa: N802
             ):
                 keyword_token = self.strip_bdd_prefix(namespace, keyword_token)
 
-            lib_entry, kw_namespace = await self.get_namespace_info_from_keyword(namespace, keyword_token)
+            lib_entry, kw_namespace = await self.get_namespace_info_from_keyword_token(namespace, keyword_token)
 
             kw_range = range_from_token(keyword_token)
 
@@ -510,7 +510,7 @@ async def _find_Template_or_TestTemplate(  # noqa: N802
                     (
                         lib_entry,
                         kw_namespace,
-                    ) = await self.get_namespace_info_from_keyword(namespace, keyword_token)
+                    ) = await self.get_namespace_info_from_keyword_token(namespace, keyword_token)
 
                     kw_range = range_from_token(keyword_token)