perf(analyzer): introduced some caching for parsing variables

Author: d-biehl

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

@@ -36,8 +36,7 @@
     Variable,
     VariablesImport,
 )
-from robot.utils.escaping import split_from_equals, unescape
-from robot.variables.search import is_variable
+from robot.utils.escaping import unescape
 
 from robotcode.core.concurrent import check_current_task_canceled
 from robotcode.core.language import language_id
@@ -70,6 +69,7 @@
     iter_over_keyword_names_and_owners,
     token_in_range,
 )
+from robotcode.robot.utils.variables import is_variable, split_from_equals
 
 from .protocol_part import RobotLanguageServerProtocolPart
 
@@ -1120,13 +1120,13 @@ def get_tokens() -> Iterator[Tuple[Token, ast.AST]]:
                         if kw_token is not None:
                             kw: Optional[str] = None
 
-                            for _, name in iter_over_keyword_names_and_owners(
+                            for _, n in iter_over_keyword_names_and_owners(
                                 ModelHelper.strip_bdd_prefix(namespace, kw_token).value
                             ):
-                                if name is not None:
-                                    matcher = KeywordMatcher(name)
+                                if n is not None:
+                                    matcher = KeywordMatcher(n)
                                     if matcher in ALL_RUN_KEYWORDS_MATCHERS:
-                                        kw = name
+                                        kw = n
                             if kw:
                                 kw_doc = namespace.find_keyword(kw_token.value)
                                 if kw_doc is not None and kw_doc.is_any_run_keyword():

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

@@ -12,11 +12,11 @@
 )
 
 from robot.parsing.lexer.tokens import Token
-from robot.variables.search import search_variable
 from robotcode.core.lsp.types import Position, Range
 from robotcode.robot.utils.match import normalize
 
 from ..utils.ast import range_from_token
+from ..utils.variables import search_variable
 
 if TYPE_CHECKING:
     from robotcode.robot.diagnostics.library_doc import KeywordDoc, LibraryDoc

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

@@ -25,6 +25,7 @@
     final,
 )
 
+from robot.libraries import STDLIBS
 from robot.utils.text import split_args_from_name_or_path
 from robotcode.core.concurrent import RLock, run_as_task
 from robotcode.core.documents_manager import DocumentsManager
@@ -43,6 +44,7 @@
 from ..__version__ import __version__
 from ..utils import get_robot_version, get_robot_version_str
 from ..utils.robot_path import find_file_ex
+from ..utils.variables import contains_variable
 from .entities import (
     CommandLineVariableDefinition,
     VariableDefinition,
@@ -1023,8 +1025,6 @@ def _find_library(
         base_dir: str,
         variables: Optional[Dict[str, Any]] = None,
     ) -> str:
-        from robot.libraries import STDLIBS
-        from robot.variables.search import contains_variable
 
         if contains_variable(name, "$@&%"):
             return find_library(
@@ -1062,8 +1062,6 @@ def __find_resource(
         file_type: str = "Resource",
         variables: Optional[Dict[str, Any]] = None,
     ) -> str:
-        from robot.variables.search import contains_variable
-
         if contains_variable(name, "$@&%"):
             return find_file(
                 name,
@@ -1102,8 +1100,6 @@ def __find_variables(
         resolve_variables: bool = True,
         resolve_command_line_vars: bool = True,
     ) -> str:
-        from robot.variables.search import contains_variable
-
         if resolve_variables and contains_variable(name, "$@&%"):
             return find_variables(
                 name,

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

@@ -62,7 +62,6 @@
 from robot.variables.filesetter import PythonImporter, YamlImporter
 from robot.variables.finders import VariableFinder
 from robot.variables.replacer import VariableReplacer
-from robot.variables.search import contains_variable
 from robotcode.core.lsp.types import Position, Range
 from robotcode.core.utils.path import normalized_path
 from robotcode.robot.diagnostics.entities import (
@@ -84,6 +83,8 @@
 from robotcode.robot.utils.match import normalize, normalize_namespace
 from robotcode.robot.utils.stubs import HasError, HasErrors
 
+from ..utils.variables import contains_variable
+
 if get_robot_version() < (7, 0):
     from robot.running.handlers import _PythonHandler, _PythonInitHandler  # pyright: ignore[reportMissingImports]
     from robot.running.model import ResourceFile  # pyright: ignore[reportMissingImports]
@@ -1669,9 +1670,8 @@ def _find_library_internal(
 
     robot_variables = None
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
-
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -1840,7 +1840,11 @@ def get_test_library(
                 library_name,
                 args,
                 create_handlers=False,
-                variables=robot_variables,
+                variables=(
+                    robot_variables
+                    if robot_variables is not None
+                    else resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+                ),
             )
             if get_robot_version() < (7, 0):
                 _ = lib.get_instance()
@@ -2099,9 +2103,8 @@ def _find_variables_internal(
 
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
-
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -2122,12 +2125,18 @@ def resolve_args(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> Tuple[Any, ...]:
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+    # robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+    robot_variables: Any = None
 
     result = []
     for arg in args:
         if isinstance(arg, str):
-            result.append(robot_variables.replace_string(arg, ignore_errors=True))
+            if contains_variable(arg, "$@&%"):
+                if robot_variables is None:
+                    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+                result.append(robot_variables.replace_string(arg, ignore_errors=True))
+            else:
+                result.append(arg)
         else:
             result.append(arg)
 
@@ -2402,8 +2411,8 @@ def find_file(
 ) -> str:
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -2505,7 +2514,7 @@ def complete_library_import(
             if e not in DEFAULT_LIBRARIES
         ]
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)
@@ -2581,7 +2590,7 @@ def complete_resource_import(
 
     result: List[CompleteResult] = []
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)
@@ -2621,7 +2630,7 @@ def complete_variables_import(
 
     result: List[CompleteResult] = []
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)

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

@@ -21,9 +21,8 @@
 
 from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
-from robot.utils.escaping import split_from_equals, unescape
+from robot.utils.escaping import unescape
 from robot.variables.finders import NOT_FOUND, NumberFinder
-from robot.variables.search import contains_variable, search_variable
 from robotcode.core.lsp.types import Position
 
 from ..utils import get_robot_version
@@ -35,6 +34,7 @@
     whitespace_at_begin_of_token,
     whitespace_from_begin_of_token,
 )
+from ..utils.variables import contains_variable, search_variable, split_from_equals
 from .entities import (
     LibraryEntry,
     VariableDefinition,

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

@@ -28,11 +28,6 @@
 from robot.parsing.model.statements import (
     VariablesImport as RobotVariablesImport,
 )
-from robot.variables.search import (
-    is_scalar_assign,
-    is_variable,
-    search_variable,
-)
 from robotcode.core.concurrent import RLock
 from robotcode.core.event import event
 from robotcode.core.lsp.types import (
@@ -57,7 +52,12 @@
     tokenize_variables,
 )
 from ..utils.stubs import Languages
-from ..utils.variables import BUILTIN_VARIABLES
+from ..utils.variables import (
+    BUILTIN_VARIABLES,
+    is_scalar_assign,
+    is_variable,
+    search_variable,
+)
 from ..utils.visitor import Visitor
 from .entities import (
     ArgumentDefinition,

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

@@ -28,9 +28,8 @@
     Variable,
     VariablesImport,
 )
-from robot.utils.escaping import split_from_equals, unescape
+from robot.utils.escaping import unescape
 from robot.variables.finders import NOT_FOUND, NumberFinder
-from robot.variables.search import contains_variable, is_scalar_assign, is_variable, search_variable
 from robotcode.core.concurrent import check_current_task_canceled
 from robotcode.core.lsp.types import (
     CodeDescription,
@@ -54,6 +53,7 @@
     strip_variable_token,
     tokenize_variables,
 )
+from ..utils.variables import contains_variable, is_scalar_assign, is_variable, search_variable, split_from_equals
 from ..utils.visitor import Visitor
 from .entities import (
     ArgumentDefinition,

packages/robot/src/robotcode/robot/utils/variables.py

@@ -1,3 +1,13 @@
+import functools
+from typing import Optional, Tuple, cast
+
+from robot.utils.escaping import split_from_equals as robot_split_from_equals
+from robot.variables.search import VariableMatch as RobotVariableMatch
+from robot.variables.search import contains_variable as robot_contains_variable
+from robot.variables.search import is_scalar_assign as robot_is_scalar_assign
+from robot.variables.search import is_variable as robot_is_variable
+from robot.variables.search import search_variable as robot_search_variable
+
 BUILTIN_VARIABLES = [
     "${CURDIR}",
     "${EMPTY}",
@@ -35,3 +45,28 @@
     "${DEBUG_FILE}",
     "${OUTPUT_DIR}",
 ]
+
+
+@functools.lru_cache(maxsize=512)
+def contains_variable(string: str, identifiers: str = "$@&") -> bool:
+    return cast(bool, robot_contains_variable(string, identifiers))
+
+
+@functools.lru_cache(maxsize=512)
+def is_scalar_assign(string: str, allow_assign_mark: bool = False) -> bool:
+    return cast(bool, robot_is_scalar_assign(string, allow_assign_mark))
+
+
+@functools.lru_cache(maxsize=512)
+def is_variable(string: str, identifiers: str = "$@&") -> bool:
+    return cast(bool, robot_is_variable(string, identifiers))
+
+
+@functools.lru_cache(maxsize=512)
+def search_variable(string: str, identifiers: str = "$@&%*", ignore_errors: bool = False) -> RobotVariableMatch:
+    return robot_search_variable(string, identifiers, ignore_errors)
+
+
+@functools.lru_cache(maxsize=512)
+def split_from_equals(string: str) -> Tuple[str, Optional[str]]:
+    return cast(Tuple[str, Optional[str]], robot_split_from_equals(string))