perf(analyzer): simplify generating of internal libdocs for resource files

Author: d-biehl

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

@@ -491,7 +491,7 @@ def generate_sem_sub_tokens(
                     )
 
                 if builtin_library_doc is not None and kw in builtin_library_doc.keywords:
-                    if kw_doc is not None and kw_doc.libname == cls.BUILTIN_MATCHER and kw_doc.matcher == kw:
+                    if kw_doc is not None and kw_doc.libname == cls.BUILTIN_MATCHER and kw_doc.matcher.match_string(kw):
                         if not sem_mod:
                             sem_mod = set()
                         sem_mod.add(RobotSemTokenModifiers.BUILTIN)

packages/robot/src/robotcode/robot/diagnostics/entities.py

@@ -1,3 +1,4 @@
+import functools
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import (
@@ -142,7 +143,7 @@ def __init__(self, name: str) -> None:
 
         self.base = match.base
 
-        self.normalized_name = str(normalize(self.base))
+        self.normalized_name = normalize(self.base)
 
     def __eq__(self, o: object) -> bool:
         if type(o) is VariableMatcher:
@@ -154,7 +155,7 @@ def __eq__(self, o: object) -> bool:
             if base is None:
                 return False
 
-            normalized = str(normalize(base))
+            normalized = normalize(base)
             return self.normalized_name == normalized
 
         return False
@@ -194,10 +195,9 @@ class VariableDefinition(SourceEntity):
     value: Any = field(default=None, compare=False)
     value_is_native: bool = field(default=False, compare=False)
 
-    matcher: VariableMatcher = field(init=False, compare=False)
-
-    def __post_init__(self) -> None:
-        self.matcher = VariableMatcher(self.name)
+    @functools.cached_property
+    def matcher(self) -> VariableMatcher:
+        return VariableMatcher(self.name)
 
     @single_call
     def __hash__(self) -> int:

packages/robot/src/robotcode/robot/diagnostics/imports_manager.py

@@ -573,12 +573,10 @@ def __init__(
         self._resource_document_changed_timer_interval = 1
         self._resource_document_changed_documents: Set[TextDocument] = set()
 
-        self._resource_libdoc_cache: "weakref.WeakKeyDictionary[ast.AST, Dict[Tuple[str, bool], LibraryDoc]]" = (
+        self._resource_libdoc_cache: "weakref.WeakKeyDictionary[ast.AST, Dict[str, LibraryDoc]]" = (
             weakref.WeakKeyDictionary()
         )
 
-        self._process_pool_executor: Optional[ProcessPoolExecutor] = None
-
     def __del__(self) -> None:
         try:
             if self._executor is not None:
@@ -1302,9 +1300,8 @@ def get_libdoc_from_model(
         self,
         model: ast.AST,
         source: str,
-        append_model_errors: bool = True,
     ) -> LibraryDoc:
-        key = (source, append_model_errors)
+        key = source
 
         entry = None
         if model in self._resource_libdoc_cache:
@@ -1313,11 +1310,7 @@ def get_libdoc_from_model(
             if entry and key in entry:
                 return entry[key]
 
-        result = get_model_doc(
-            model=model,
-            source=source,
-            append_model_errors=append_model_errors,
-        )
+        result = get_model_doc(model=model, source=source)
         if entry is None:
             entry = {}
             self._resource_libdoc_cache[model] = entry

packages/robot/src/robotcode/robot/diagnostics/keyword_finder.py

@@ -39,9 +39,8 @@ class CancelSearchError(Exception):
 
 
 class KeywordFinder:
-    def __init__(self, namespace: "Namespace", library_doc: LibraryDoc) -> None:
-        self.namespace = namespace
-        self.self_library_doc = library_doc
+    def __init__(self, namespace: "Namespace") -> None:
+        self._namespace = namespace
 
         self.diagnostics: List[DiagnosticsEntry] = []
         self.result_bdd_prefix: Optional[str] = None
@@ -57,9 +56,9 @@ def __init__(self, namespace: "Namespace", library_doc: LibraryDoc) -> None:
             ],
         ] = {}
 
-        self._all_keywords: Optional[List[LibraryEntry]] = None
-        self._resource_imports: Optional[List[ResourceEntry]] = None
-        self._library_imports: Optional[List[LibraryEntry]] = None
+    @functools.cached_property
+    def _library_doc(self) -> LibraryDoc:
+        return self._namespace.get_library_doc()
 
     def reset_diagnostics(self) -> None:
         self.diagnostics = []
@@ -162,7 +161,7 @@ def _find_keyword(
     def _get_keyword_from_self(self, name: str) -> Optional[KeywordDoc]:
         if get_robot_version() >= (6, 0):
             found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
-                (None, v) for v in self.self_library_doc.keywords.iter_all(name)
+                (None, v) for v in self._library_doc.keywords.iter_all(name)
             ]
             if len(found) > 1:
                 found = self._select_best_matches(found)
@@ -183,7 +182,7 @@ def _get_keyword_from_self(self, name: str) -> Optional[KeywordDoc]:
             return None
 
         try:
-            return self.self_library_doc.keywords.get(name, None)
+            return self._library_doc.keywords.get(name, None)
         except KeywordError as e:
             self.diagnostics.append(DiagnosticsEntry(str(e), DiagnosticSeverity.ERROR, Error.KEYWORD_ERROR))
             raise CancelSearchError from e
@@ -213,15 +212,16 @@ def _get_explicit_keyword(self, name: str) -> Optional[KeywordDoc]:
 
         return found[0][1] if found else None
 
-    def find_keywords(self, owner_name: str, name: str) -> List[Tuple[LibraryEntry, KeywordDoc]]:
-        if self._all_keywords is None:
-            self._all_keywords = list(
-                chain(
-                    self.namespace._libraries.values(),
-                    self.namespace._resources.values(),
-                )
+    @functools.cached_property
+    def _all_keywords(self) -> List[LibraryEntry]:
+        return list(
+            chain(
+                self._namespace._libraries.values(),
+                self._namespace._resources.values(),
             )
+        )
 
+    def find_keywords(self, owner_name: str, name: str) -> List[Tuple[LibraryEntry, KeywordDoc]]:
         if get_robot_version() >= (6, 0):
             result: List[Tuple[LibraryEntry, KeywordDoc]] = []
             for v in self._all_keywords:
@@ -271,11 +271,11 @@ def _get_implicit_keyword(self, name: str) -> Optional[KeywordDoc]:
     def _prioritize_same_file_or_public(
         self, entries: List[Tuple[Optional[LibraryEntry], KeywordDoc]]
     ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        matches = [h for h in entries if h[1].source == self.namespace.source]
+        matches = [h for h in entries if h[1].source == self._namespace.source]
         if matches:
             return matches
 
-        matches = [handler for handler in entries if not handler[1].is_private()]
+        matches = [handler for handler in entries if not handler[1].is_private]
 
         return matches or entries
 
@@ -318,10 +318,11 @@ def _is_better_match(
             and candidate[1].matcher.embedded_arguments.match(other[1].name) is None
         )
 
-    def _get_keyword_from_resource_files(self, name: str) -> Optional[KeywordDoc]:
-        if self._resource_imports is None:
-            self._resource_imports = list(chain(self.namespace._resources.values()))
+    @functools.cached_property
+    def _resource_imports(self) -> List[ResourceEntry]:
+        return list(chain(self._namespace._resources.values()))
 
+    def _get_keyword_from_resource_files(self, name: str) -> Optional[KeywordDoc]:
         if get_robot_version() >= (6, 0):
             found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
                 (v, k) for v in self._resource_imports for k in v.library_doc.keywords.iter_all(name)
@@ -365,17 +366,18 @@ def _get_keyword_from_resource_files(self, name: str) -> Optional[KeywordDoc]:
     def _get_keyword_based_on_search_order(
         self, entries: List[Tuple[Optional[LibraryEntry], KeywordDoc]]
     ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        for libname in self.namespace.search_order:
+        for libname in self._namespace.search_order:
             for e in entries:
                 if e[0] is not None and eq_namespace(libname, e[0].alias or e[0].name):
                     return [e]
 
         return entries
 
-    def _get_keyword_from_libraries(self, name: str) -> Optional[KeywordDoc]:
-        if self._library_imports is None:
-            self._library_imports = list(chain(self.namespace._libraries.values()))
+    @functools.cached_property
+    def _library_imports(self) -> List[LibraryEntry]:
+        return list(chain(self._namespace._libraries.values()))
 
+    def _get_keyword_from_libraries(self, name: str) -> Optional[KeywordDoc]:
         if get_robot_version() >= (6, 0):
             found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
                 (v, k) for v in self._library_imports for k in v.library_doc.keywords.iter_all(name)
@@ -462,8 +464,8 @@ def _create_custom_and_standard_keyword_conflict_warning_message(
     def bdd_prefix_regexp(self) -> "re.Pattern[str]":
         prefixes = (
             "|".join(
-                self.namespace.languages.bdd_prefixes
-                if self.namespace.languages is not None
+                self._namespace.languages.bdd_prefixes
+                if self._namespace.languages is not None
                 else ["given", "when", "then", "and", "but"]
             )
             .replace(" ", r"\s")