fix(langserver): correct highlight, completion, analyze, etc. keyword calls with . that are also valid namespaces

Author: d-biehl

packages/language_server/src/robotcode/language_server/common/parts/completion.py

@@ -12,6 +12,7 @@
     CompletionItem,
     CompletionList,
     CompletionOptions,
+    CompletionOptionsCompletionItemType,
     CompletionParams,
     CompletionTriggerKind,
     InsertReplaceEdit,
@@ -78,6 +79,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
                 all_commit_characters=commit_chars if commit_chars else None,
                 resolve_provider=len(self.resolve) > 0,
                 work_done_progress=True,
+                completion_item=CompletionOptionsCompletionItemType(label_details_support=True),
             )
 
     @rpc_method(name="textDocument/completion", param_type=CompletionParams)

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

@@ -426,28 +426,11 @@ async def _analyze_keyword_call(
                 result is not None
                 and lib_entry is not None
                 and kw_namespace
-                and result.parent_digest is not None
-                and result.parent_digest != lib_entry.library_doc.digest
+                and result.parent is not None
+                and result.parent != lib_entry.library_doc
             ):
-                entry = next(
-                    (
-                        v
-                        for v in (await self.namespace.get_libraries()).values()
-                        if v.library_doc.digest == result.parent_digest
-                    ),
-                    None,
-                )
-                if entry is None:
-                    entry = next(
-                        (
-                            v
-                            for v in (await self.namespace.get_resources()).values()
-                            if v.library_doc.digest == result.parent_digest
-                        ),
-                        None,
-                    )
-                if entry is not None:
-                    lib_entry = entry
+                lib_entry = None
+                kw_range = range_from_token(keyword_token)
 
             if kw_namespace and lib_entry is not None and lib_range is not None:
                 if self.namespace.document is not None:

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

@@ -44,7 +44,7 @@
 from robotcode.language_server.robotframework.utils.markdownformatter import (
     MarkDownFormatter,
 )
-from robotcode.language_server.robotframework.utils.match import normalize
+from robotcode.language_server.robotframework.utils.match import normalize, normalize_namespace
 from robotcode.language_server.robotframework.utils.version import get_robot_version
 
 from .entities import (
@@ -150,16 +150,17 @@ def is_embedded_keyword(name: str) -> bool:
 
 
 class KeywordMatcher:
-    def __init__(self, name: str, can_have_embedded: bool = True) -> None:
+    def __init__(self, name: str, can_have_embedded: bool = True, is_namespace: bool = False) -> None:
         self.name = name
-        self._can_have_embedded = can_have_embedded
+        self._can_have_embedded = can_have_embedded and not is_namespace
+        self._is_namespace = is_namespace
         self._normalized_name: Optional[str] = None
         self._embedded_arguments: Any = None
 
     @property
     def normalized_name(self) -> str:
         if self._normalized_name is None:
-            self._normalized_name = str(normalize(self.name))
+            self._normalized_name = str(normalize_namespace(self.name) if self._is_namespace else normalize(self.name))
 
         return self._normalized_name
 
@@ -198,7 +199,7 @@ def __eq__(self, o: Any) -> bool:
 
             return self.embedded_arguments.name.match(o) is not None
 
-        return self.normalized_name == str(normalize(o))
+        return self.normalized_name == str(normalize_namespace(o) if self._is_namespace else normalize(o))
 
     @single_call
     def __hash__(self) -> int:

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

@@ -51,7 +51,7 @@
     tokenize_variables,
 )
 from robotcode.language_server.robotframework.utils.async_ast import Visitor
-from robotcode.language_server.robotframework.utils.match import eq
+from robotcode.language_server.robotframework.utils.match import eq_namespace
 from robotcode.language_server.robotframework.utils.variables import BUILTIN_VARIABLES
 from robotcode.language_server.robotframework.utils.version import get_robot_version
 
@@ -740,7 +740,7 @@ async def get_libraries(self) -> OrderedDict[str, LibraryEntry]:
     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, False): v
+                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
@@ -753,7 +753,7 @@ async def get_resources(self) -> OrderedDict[str, ResourceEntry]:
     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, False): v
+                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
@@ -1839,13 +1839,13 @@ def find_keywords(self, owner_name: str, name: str) -> List[Tuple[LibraryEntry,
         if get_robot_version() >= (6, 0):
             result: List[Tuple[LibraryEntry, KeywordDoc]] = []
             for v in self._all_keywords:
-                if eq(v.alias or v.name, owner_name):
+                if eq_namespace(v.alias or v.name, owner_name):
                     result.extend((v, kw) for kw in v.library_doc.keywords.get_all(name))
             return result
 
         result = []
         for v in self._all_keywords:
-            if eq(v.alias or v.name, owner_name):
+            if eq_namespace(v.alias or v.name, owner_name):
                 kw = v.library_doc.keywords.get(name, None)
                 if kw is not None:
                     result.append((v, kw))
@@ -1973,7 +1973,7 @@ def _get_keyword_based_on_search_order(
     ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
         for libname in self.namespace.search_order:
             for e in entries:
-                if e[0] is not None and eq(libname, e[0].alias or e[0].name):
+                if e[0] is not None and eq_namespace(libname, e[0].alias or e[0].name):
                     return [e]
 
         return entries

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

@@ -720,6 +720,10 @@ async def create_keyword_completion_items(
             if not has_bdd and token is not None:
                 token = old_token
 
+        namespace_name = None
+        namespace_matcher = None
+        valid_namespace = False
+
         if token is not None:
             r = range_from_token(token)
 
@@ -737,20 +741,21 @@ def enumerate_indexes(s: str, c: str) -> Iterator[int]:
                         lib_name_index = e
 
                 if lib_name_index >= 0:
-                    library_name = token.value[0 : lib_name_index - r.start.character]
+                    namespace_name = token.value[0 : lib_name_index - r.start.character]
 
                     libraries = await self.namespace.get_libraries()
 
-                    library_name_matcher = KeywordMatcher(library_name)
-                    library_name = next(
-                        (e for e in libraries.keys() if library_name_matcher == KeywordMatcher(e)), library_name
+                    namespace_matcher = KeywordMatcher(namespace_name, is_namespace=True)
+                    namespace_name = next(
+                        (e for e in libraries.keys() if namespace_matcher == KeywordMatcher(e, is_namespace=True)),
+                        namespace_name,
                     )
-                    valid_namespace = False
-                    if library_name in libraries:
+
+                    if namespace_name in libraries:
                         valid_namespace = True
 
                         r.start.character = lib_name_index + 1
-                        for kw in libraries[library_name].library_doc.keywords.values():
+                        for kw in libraries[namespace_name].library_doc.keywords.values():
                             if kw.is_error_handler:
                                 continue
                             result.append(
@@ -759,7 +764,7 @@ def enumerate_indexes(s: str, c: str) -> Iterator[int]:
                                     kind=CompletionItemKind.FUNCTION,
                                     detail=f"{CompleteResultKind.KEYWORD.value} "
                                     f"{f'({kw.libname})' if kw.libname is not None else ''}",
-                                    sort_text=f"020_{kw.name}",
+                                    sort_text=f"019_{kw.name}",
                                     insert_text_format=InsertTextFormat.PLAIN_TEXT
                                     if not kw.is_embedded
                                     else InsertTextFormat.SNIPPET,
@@ -785,7 +790,7 @@ def enumerate_indexes(s: str, c: str) -> Iterator[int]:
                     resources = {
                         k: v
                         for k, v in (await self.namespace.get_resources()).items()
-                        if library_name_matcher == KeywordMatcher(v.name)
+                        if namespace_matcher == KeywordMatcher(v.name, is_namespace=True)
                     }
 
                     if resources:
@@ -802,7 +807,7 @@ def enumerate_indexes(s: str, c: str) -> Iterator[int]:
                                         kind=CompletionItemKind.FUNCTION,
                                         detail=f"{CompleteResultKind.KEYWORD.value} "
                                         f"{f'({kw.libname})' if kw.libname is not None else ''}",
-                                        sort_text=f"020_{kw.name}",
+                                        sort_text=f"019_{kw.name}",
                                         insert_text_format=InsertTextFormat.PLAIN_TEXT
                                         if not kw.is_embedded
                                         else InsertTextFormat.SNIPPET,
@@ -822,15 +827,25 @@ def enumerate_indexes(s: str, c: str) -> Iterator[int]:
                                         ),
                                     )
                                 )
-                    if result and valid_namespace:
-                        return result
+
+        if token is not None:
+            r = range_from_token(token)
 
         if r is None:
             r = Range(position, position)
 
+        if namespace_matcher is not None:
+            namespace_matcher = KeywordMatcher(namespace_matcher.name)
+
         for kw in await self.namespace.get_keywords():
             if kw.is_error_handler:
                 continue
+            if (
+                valid_namespace
+                and namespace_matcher is not None
+                and not kw.matcher.normalized_name.startswith(namespace_matcher.normalized_name)
+            ):
+                continue
 
             result.append(
                 CompletionItem(
@@ -855,6 +870,9 @@ def enumerate_indexes(s: str, c: str) -> Iterator[int]:
                 )
             )
 
+        if valid_namespace and namespace_matcher is not None:
+            return result
+
         for k, v in (await self.namespace.get_libraries()).items():
             result.append(
                 CompletionItem(

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

@@ -261,7 +261,7 @@ def mapping(cls) -> Dict[str, Tuple[Enum, Optional[Set[Enum]]]]:
     )
     BDD_TOKEN_REGEX = re.compile(r"^(Given|When|Then|And|But)\s", flags=re.IGNORECASE)
 
-    BUILTIN_MATCHER = KeywordMatcher("BuiltIn")
+    BUILTIN_MATCHER = KeywordMatcher("BuiltIn", is_namespace=True)
 
     @classmethod
     async def generate_sem_sub_tokens(
@@ -382,11 +382,20 @@ async def generate_sem_sub_tokens(
 
                 kw_namespace: Optional[str] = None
                 kw: str = token.value
+                kw_doc = await namespace.find_keyword(token.value, raise_keyword_error=False)
 
                 for lib, name in iter_over_keyword_names_and_owners(token.value):
                     if lib is not None and (
-                        any(k for k in libraries_matchers.keys() if k == lib)
-                        or any(k for k in resources_matchers.keys() if k == lib)
+                        any(
+                            k
+                            for k, v in libraries_matchers.items()
+                            if k == lib and (kw_doc is None or kw_doc.parent == v.library_doc)
+                        )
+                        or any(
+                            k
+                            for k, v in resources_matchers.items()
+                            if k == lib and (kw_doc is None or kw_doc.parent == v.library_doc)
+                        )
                     ):
                         kw_namespace = lib
                         if name:
@@ -411,13 +420,11 @@ async def generate_sem_sub_tokens(
                     )
 
                 if builtin_library_doc is not None and kw in builtin_library_doc.keywords:
-                    doc = await namespace.find_keyword(token.value)
-                    if doc is not None and doc.libname == cls.BUILTIN_MATCHER and doc.matcher == kw:
+                    if kw_doc is not None and kw_doc.libname == cls.BUILTIN_MATCHER and kw_doc.matcher == kw:
                         if not sem_mod:
                             sem_mod = set()
                         sem_mod.add(RobotSemTokenModifiers.BUILTIN)
 
-                kw_doc = await namespace.find_keyword(token.value, raise_keyword_error=False)
                 if kw_doc is not None and kw_doc.is_embedded:
                     if get_robot_version() >= (6, 0):
                         m = kw_doc.matcher.embedded_arguments.match(kw)

packages/language_server/src/robotcode/language_server/robotframework/utils/match.py

@@ -6,7 +6,18 @@ def normalize(text: str) -> str:
     return text.lower().replace("_", "").replace(" ", "")
 
 
+@lru_cache(maxsize=5000)
+def normalize_namespace(text: str) -> str:
+    return text.lower().replace(" ", "")
+
+
 def eq(str1: str, str2: str) -> bool:
     str1 = normalize(str1)
     str2 = normalize(str2)
     return str1 == str2
+
+
+def eq_namespace(str1: str, str2: str) -> bool:
+    str1 = normalize_namespace(str1)
+    str2 = normalize_namespace(str2)
+    return str1 == str2