perf(analyzer): speed up finding keywords and variables a little bit more

Author: d-biehl

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

@@ -145,10 +145,10 @@ def __init__(self, name: str) -> None:
         self.normalized_name = str(normalize(self.base))
 
     def __eq__(self, o: object) -> bool:
-        if isinstance(o, VariableMatcher):
+        if type(o) is VariableMatcher:
             return o.normalized_name == self.normalized_name
 
-        if isinstance(o, str):
+        if type(o) is str:
             match = search_variable(o, "$@&%", ignore_errors=True)
             base = match.base
             if base is None:

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

@@ -58,8 +58,8 @@ def __init__(self, namespace: "Namespace", library_doc: LibraryDoc) -> None:
         ] = {}
 
         self._all_keywords: Optional[List[LibraryEntry]] = None
-        self._resource_keywords: Optional[List[ResourceEntry]] = None
-        self._library_keywords: Optional[List[LibraryEntry]] = None
+        self._resource_imports: Optional[List[ResourceEntry]] = None
+        self._library_imports: Optional[List[LibraryEntry]] = None
 
     def reset_diagnostics(self) -> None:
         self.diagnostics = []
@@ -312,23 +312,23 @@ def _is_better_match(
         other: Tuple[Optional[LibraryEntry], KeywordDoc],
     ) -> bool:
         return (
-            other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
+            other[1].matcher.embedded_arguments is not None
+            and candidate[1].matcher.embedded_arguments is not None
+            and other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
             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_keywords is None:
-            self._resource_keywords = list(chain(self.namespace._resources.values()))
+        if self._resource_imports is None:
+            self._resource_imports = list(chain(self.namespace._resources.values()))
 
         if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._resource_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
+            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
+                (v, k) for v in self._resource_imports for k in v.library_doc.keywords.iter_all(name)
+            ]
         else:
             found = []
-            for k in self._resource_keywords:
+            for k in self._resource_imports:
                 s = k.library_doc.keywords.get(name, None)
                 if s is not None:
                     found.append((k, s))
@@ -373,19 +373,18 @@ def _get_keyword_based_on_search_order(
         return entries
 
     def _get_keyword_from_libraries(self, name: str) -> Optional[KeywordDoc]:
-        if self._library_keywords is None:
-            self._library_keywords = list(chain(self.namespace._libraries.values()))
+        if self._library_imports is None:
+            self._library_imports = list(chain(self.namespace._libraries.values()))
 
         if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._library_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
+            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
+                (v, k) for v in self._library_imports for k in v.library_doc.keywords.iter_all(name)
+            ]
+
         else:
             found = []
 
-            for k in self._library_keywords:
+            for k in self._library_imports:
                 s = k.library_doc.keywords.get(name, None)
                 if s is not None:
                     found.append((k, s))

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

@@ -240,29 +240,27 @@ def __init__(
         self._is_namespace = is_namespace
         self._normalized_name: Optional[str] = None
 
+        self.embedded_arguments: Optional[EmbeddedArguments] = (
+            _get_embedded_arguments(self.name) or None if self._can_have_embedded else None
+        )
+        self._match_cache: Dict[str, bool] = {}
+
     @property
     def normalized_name(self) -> str:
         if self._normalized_name is None:
             self._normalized_name = str(normalize_namespace(self.name) if self._is_namespace else normalize(self.name))
 
         return self._normalized_name
 
-    @functools.cached_property
-    def embedded_arguments(self) -> Any:
-        if self._can_have_embedded:
-            return _get_embedded_arguments(self.name) or ()
-
-        return ()
-
     if get_robot_version() >= (6, 0):
 
         def __match_embedded(self, name: str) -> bool:
-            return self.embedded_arguments.match(name) is not None
+            return self.embedded_arguments is not None and self.embedded_arguments.match(name) is not None
 
     else:
 
         def __match_embedded(self, name: str) -> bool:
-            return self.embedded_arguments.name.match(name) is not None
+            return self.embedded_arguments is not None and self.embedded_arguments.name.match(name) is not None
 
     def __eq__(self, o: object) -> bool:
         if type(o) is KeywordMatcher:
@@ -274,7 +272,7 @@ def __eq__(self, o: object) -> bool:
 
             o = o.name
 
-        if not cached_isinstance(o, str):
+        if type(o) is not str:
             return False
 
         if self.embedded_arguments: