perf(robotlangserver): Speedup keyword completion

Recalcution of useable keywords is only called if imports changed, this should speedup showing the completion window for keywords

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -518,7 +518,7 @@ class KeywordStore:
     @property
     def _matchers(self) -> Dict[KeywordMatcher, KeywordDoc]:
         if not hasattr(self, "__matchers"):
-            self.__matchers = {KeywordMatcher(v.name): v for v in self.keywords}
+            self.__matchers = {v.matcher: v for v in self.keywords}
         return self.__matchers
 
     def __getitem__(self, key: str) -> "KeywordDoc":
@@ -563,6 +563,9 @@ def keys(self) -> AbstractSet[str]:
     def values(self) -> AbstractSet[KeywordDoc]:
         return {v for v in self.keywords}
 
+    def __iter__(self) -> Iterator[KeywordDoc]:
+        return self.keywords.__iter__()
+
     def get(self, key: str, default: Optional[KeywordDoc] = None) -> Optional[KeywordDoc]:
         try:
             return self.__getitem__(key)

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -589,8 +589,9 @@ def __init__(
         self._keyword_references: Dict[KeywordDoc, Set[Location]] = {}
         self._variable_references: Dict[VariableDefinition, Set[Location]] = {}
 
+        self._imported_keywords: Optional[List[KeywordDoc]] = None
+        self._imported_keywords_lock = Lock()
         self._keywords: Optional[List[KeywordDoc]] = None
-
         self._keywords_lock = Lock()
 
         # TODO: how to get the search order from model
@@ -673,6 +674,7 @@ async def _invalidate(self) -> None:
         self._imports = None
         self._import_entries = OrderedDict()
         self._own_variables = None
+        self._imported_keywords = None
         self._keywords = None
         self._library_doc = None
         self._analyzed = False
@@ -766,6 +768,7 @@ class DataEntry(NamedTuple):
         variables: OrderedDict[str, VariablesEntry] = OrderedDict()
         diagnostics: List[Diagnostic] = []
         import_entries: OrderedDict[Import, LibraryEntry] = OrderedDict()
+        imported_keywords: Optional[List[KeywordDoc]] = None
 
     @_logger.call(condition=lambda self: not self._initialized)
     async def ensure_initialized(self) -> bool:
@@ -812,8 +815,10 @@ async def ensure_initialized(self) -> bool:
                         self._variables = data_entry.variables.copy()
                         self._diagnostics = data_entry.diagnostics.copy()
                         self._import_entries = data_entry.import_entries.copy()
+                        self._imported_keywords = (
+                            data_entry.imported_keywords.copy() if data_entry.imported_keywords else None
+                        )
                     else:
-
                         variables = await self.get_resolvable_variables()
 
                         await self._import_default_libraries(variables)
@@ -830,6 +835,7 @@ async def ensure_initialized(self) -> bool:
                                     self._variables.copy(),
                                     self._diagnostics.copy(),
                                     self._import_entries.copy(),
+                                    self._imported_keywords.copy() if self._imported_keywords else None,
                                 ),
                             )
 
@@ -1475,16 +1481,27 @@ async def get_imported_variables_libdoc(self, name: str, args: Tuple[str, ...] =
             None,
         )
 
+    async def get_imported_keywords(self) -> List[KeywordDoc]:
+        async with self._imported_keywords_lock:
+            if self._imported_keywords is None:
+                self._imported_keywords = list(
+                    itertools.chain(
+                        *(e.library_doc.keywords for e in self._libraries.values()),
+                        *(e.library_doc.keywords for e in self._resources.values()),
+                    )
+                )
+
+            return self._imported_keywords
+
     @_logger.call
     async def iter_all_keywords(self) -> AsyncGenerator[KeywordDoc, None]:
         import itertools
 
         libdoc = await self.get_library_doc()
 
         for doc in itertools.chain(
-            *(e.library_doc.keywords.values() for e in self._libraries.values()),
-            *(e.library_doc.keywords.values() for e in self._resources.values()),
-            libdoc.keywords.values() if libdoc is not None else [],
+            await self.get_imported_keywords(),
+            libdoc.keywords if libdoc is not None else [],
         ):
             yield doc
 
@@ -1504,10 +1521,13 @@ async def get_keywords(self) -> List[KeywordDoc]:
 
                     async for doc in self.iter_all_keywords():
                         i += 1
-                        result[KeywordMatcher(doc.name)] = doc
+                        result[doc.matcher] = doc
 
                     self._keywords = list(result.values())
-                finally:
+                except BaseException:
+                    self._logger.debug("Canceled collecting keywords ")
+                    raise
+                else:
                     self._logger.debug(
                         lambda: f"end collecting {len(self._keywords) if self._keywords else 0}"
                         f" keywords in {time.monotonic()-current_time}s analyze {i} keywords"

robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -403,11 +403,7 @@ 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 KeywordMatcher(doc.name) == KeywordMatcher(kw)
-                    ):
+                    if doc is not None and doc.libname == cls.BUILTIN_MATCHER and doc.matcher == kw:
                         if not sem_mod:
                             sem_mod = set()
                         sem_mod.add(RobotSemTokenModifiers.BUILTIN)