refactor(all): some cache adjustments and removal of unnecessary code

Author: d-biehl

packages/core/src/robotcode/core/text_document.py

@@ -48,7 +48,7 @@ def position_from_utf16(lines: List[str], position: Position) -> Position:
     return Position(line=position.line, character=utf32_offset)
 
 
-@functools.lru_cache(maxsize=2048)
+@functools.lru_cache(maxsize=8192)
 def has_multibyte_char(line: str) -> bool:
     return any(is_multibyte_char(c) for c in line)
 

packages/core/src/robotcode/core/utils/glob_path.py

@@ -60,7 +60,7 @@ def _glob_pattern_to_re(pattern: str) -> str:
     return result
 
 
-@functools.lru_cache(maxsize=256)
+@functools.lru_cache(maxsize=8192)
 def _compile_glob_pattern(pattern: str) -> "re.Pattern[str]":
     return re.compile(_glob_pattern_to_re(pattern))
 

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

@@ -35,7 +35,6 @@
     range_from_node,
     range_from_token,
 )
-from robotcode.robot.utils.stubs import BodyBlock
 
 from ...common.decorators import code_action_kinds
 from .code_action_helper_mixin import (
@@ -188,9 +187,9 @@ def get_valid_nodes_in_range(self, model: ast.AST, range: Range, also_return: bo
 
         result = []
 
-        blocks: List[BodyBlock] = []
+        blocks: List[Block] = []
         for node in iter_nodes(model):
-            if isinstance(node, Block) and isinstance(node, BodyBlock):
+            if isinstance(node, Block) and hasattr(node, "body"):
                 blocks.append(node)
 
             r = range_from_node(node, skip_non_data=True, allow_comments=True)

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

@@ -80,23 +80,23 @@ def visit_Statement(self, statement: ast.AST) -> None:  # noqa: N802
             self.last_statement = statement
 
 
+_NON_DATA_TOKENS = {
+    Token.SEPARATOR,
+    Token.CONTINUATION,
+    Token.EOL,
+    Token.EOS,
+}
+
+_NON_DATA_TOKENS_WITH_COMMENT = {*_NON_DATA_TOKENS, Token.COMMENT}
+
+
 def _get_non_data_range_from_node(
     node: ast.AST, only_start: bool = False, allow_comments: bool = False
 ) -> Optional[Range]:
+    non_data_tokens = _NON_DATA_TOKENS_WITH_COMMENT if allow_comments else _NON_DATA_TOKENS
     if cached_isinstance(node, Statement) and node.tokens:
         start_token = next(
-            (
-                v
-                for v in node.tokens
-                if v.type
-                not in [
-                    Token.SEPARATOR,
-                    *([] if allow_comments else [Token.COMMENT]),
-                    Token.CONTINUATION,
-                    Token.EOL,
-                    Token.EOS,
-                ]
-            ),
+            (v for v in node.tokens if v.type not in non_data_tokens),
             None,
         )
 
@@ -106,18 +106,7 @@ def _get_non_data_range_from_node(
             end_tokens = node.tokens
 
         end_token = next(
-            (
-                v
-                for v in reversed(end_tokens)
-                if v.type
-                not in [
-                    Token.SEPARATOR,
-                    *([] if allow_comments else [Token.COMMENT]),
-                    Token.CONTINUATION,
-                    Token.EOL,
-                    Token.EOS,
-                ]
-            ),
+            (v for v in reversed(end_tokens) if v.type not in non_data_tokens),
             None,
         )
         if start_token is not None and end_token is not None:
@@ -282,35 +271,35 @@ def tokenize_variables(
     return _tokenize_variables(token, variables)
 
 
-if get_robot_version() < (7, 0):
-
-    def _tokenize_variables(token: Token, variables: Any) -> Iterator[Token]:
-        lineno = token.lineno
-        col_offset = token.col_offset
-        remaining = ""
-        for before, variable, remaining in variables:
-            if before:
-                yield Token(token.type, before, lineno, col_offset)
-                col_offset += len(before)
-            yield Token(Token.VARIABLE, variable, lineno, col_offset)
-            col_offset += len(variable)
-        if remaining:
-            yield Token(token.type, remaining, lineno, col_offset)
-
-else:
-
-    def _tokenize_variables(token: Token, variables: Any) -> Iterator[Token]:
-        lineno = token.lineno
-        col_offset = token.col_offset
-        after = ""
-        for match in variables:
-            if match.before:
-                yield Token(token.type, match.before, lineno, col_offset)
-            yield Token(Token.VARIABLE, match.match, lineno, col_offset + match.start)
-            col_offset += match.end
-            after = match.after
-        if after:
-            yield Token(token.type, after, lineno, col_offset)
+def _tokenize_variables_before7(token: Token, variables: Any) -> Iterator[Token]:
+    lineno = token.lineno
+    col_offset = token.col_offset
+    remaining = ""
+    for before, variable, remaining in variables:
+        if before:
+            yield Token(token.type, before, lineno, col_offset)
+            col_offset += len(before)
+        yield Token(Token.VARIABLE, variable, lineno, col_offset)
+        col_offset += len(variable)
+    if remaining:
+        yield Token(token.type, remaining, lineno, col_offset)
+
+
+def _tokenize_variables_v7(token: Token, variables: Any) -> Iterator[Token]:
+    lineno = token.lineno
+    col_offset = token.col_offset
+    after = ""
+    for match in variables:
+        if match.before:
+            yield Token(token.type, match.before, lineno, col_offset)
+        yield Token(Token.VARIABLE, match.match, lineno, col_offset + match.start)
+        col_offset += match.end
+        after = match.after
+    if after:
+        yield Token(token.type, after, lineno, col_offset)
+
+
+_tokenize_variables = _tokenize_variables_before7 if get_robot_version() < (7, 0) else _tokenize_variables_v7
 
 
 def iter_over_keyword_names_and_owners(

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

@@ -3,7 +3,7 @@
 import itertools
 import re
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Iterator, List, Optional, Tuple
+from typing import Any, Callable, Final, Iterator, List, Optional, Tuple
 
 
 class Formatter(ABC):
@@ -87,7 +87,7 @@ def format_line(self, line: str) -> str: ...
 
 
 class HeaderFormatter(SingleLineFormatter):
-    _regex = re.compile(r"^(={1,5})\s+(\S.*?)\s+\1$")
+    _regex: Final["re.Pattern[str]"] = re.compile(r"^(={1,5})\s+(\S.*?)\s+\1$")
 
     def match(self, line: str) -> Optional[re.Match[str]]:
         return self._regex.match(line)
@@ -103,8 +103,8 @@ def format_line(self, line: str) -> str:
 
 class LinkFormatter:
     _image_exts = (".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg")
-    _link = re.compile(r"\[(.+?\|.*?)\]")
-    _url = re.compile(
+    _link: Final["re.Pattern[str]"] = re.compile(r"\[(.+?\|.*?)\]")
+    _url: Final["re.Pattern[str]"] = re.compile(
         r"""
 ((^|\ ) ["'(\[{]*)           # begin of line or space and opt. any char "'([{
 ([a-z][\w+-.]*://[^\s|]+?)   # url
@@ -177,7 +177,7 @@ def _is_image(self, text: str) -> bool:
 
 
 class LineFormatter:
-    _bold = re.compile(
+    _bold: Final["re.Pattern[str]"] = re.compile(
         r"""
 (                         # prefix (group 1)
   (^|\ )                  # begin of line or space
@@ -193,7 +193,7 @@ class LineFormatter:
 """,
         re.VERBOSE,
     )
-    _italic = re.compile(
+    _italic: Final["re.Pattern[str]"] = re.compile(
         r"""
 ( (^|\ ) ["'(]* )          # begin of line or space and opt. any char "'(
 _                          # start of italic
@@ -203,7 +203,7 @@ class LineFormatter:
 """,
         re.VERBOSE,
     )
-    _code = re.compile(
+    _code: Final["re.Pattern[str]"] = re.compile(
         r"""
 ( (^|\ ) ["'(]* )          # same as above with _ changed to ``
 ``
@@ -296,7 +296,7 @@ def _combine_lines(self, lines: List[str]) -> Iterator[str]:
 
 
 class RulerFormatter(SingleLineFormatter):
-    regex = re.compile("^-{3,}$")
+    regex: Final["re.Pattern[str]"] = re.compile("^-{3,}$")
 
     def match(self, line: str) -> Optional[re.Match[str]]:
         return self.regex.match(line)
@@ -306,9 +306,9 @@ def format_line(self, line: str) -> str:
 
 
 class TableFormatter(Formatter):
-    _table_line = re.compile(r"^\| (.* |)\|$")
-    _line_splitter = re.compile(r" \|(?= )")
-    _format_cell_content = _line_formatter.format
+    _table_line: Final["re.Pattern[str]"] = re.compile(r"^\| (.* |)\|$")
+    _line_splitter: Final["re.Pattern[str]"] = re.compile(r" \|(?= )")
+    _format_cell_content: Final[Callable[[str], str]] = _line_formatter.format
 
     def _handles(self, line: str) -> bool:
         return self._table_line.match(line) is not None

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

@@ -2,16 +2,17 @@
 
 _transform_table = str.maketrans("", "", "_ ")
 
+_transform_table_namespace = str.maketrans("", "", " ")
 
-@lru_cache(maxsize=None)
+
+@lru_cache(maxsize=8192)
 def normalize(text: str) -> str:
-    # return text.lower().replace("_", "").replace(" ", "")
-    return text.casefold().translate(_transform_table)
+    return text.translate(_transform_table).casefold()
 
 
-@lru_cache(maxsize=None)
+@lru_cache(maxsize=8192)
 def normalize_namespace(text: str) -> str:
-    return text.lower().replace(" ", "")
+    return text.translate(_transform_table_namespace).casefold()
 
 
 def eq(str1: str, str2: str) -> bool:

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

@@ -1,12 +1,6 @@
-from typing import Any, Dict, Iterator, List, Protocol, Set, runtime_checkable
+from typing import Any, Dict, Iterator, List, Protocol, Set
 
 
-@runtime_checkable
-class BodyBlock(Protocol):
-    body: List[Any]
-
-
-@runtime_checkable
 class Languages(Protocol):
     languages: List[Any]
     headers: Dict[str, str]

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

@@ -47,26 +47,26 @@
 ]
 
 
-@functools.lru_cache(maxsize=512)
+@functools.lru_cache(maxsize=8192)
 def contains_variable(string: str, identifiers: str = "$@&") -> bool:
     return cast(bool, robot_contains_variable(string, identifiers))
 
 
-@functools.lru_cache(maxsize=512)
+@functools.lru_cache(maxsize=8192)
 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)
+@functools.lru_cache(maxsize=8192)
 def is_variable(string: str, identifiers: str = "$@&") -> bool:
     return cast(bool, robot_is_variable(string, identifiers))
 
 
-@functools.lru_cache(maxsize=512)
+@functools.lru_cache(maxsize=8192)
 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)
+@functools.lru_cache(maxsize=8192)
 def split_from_equals(string: str) -> Tuple[str, Optional[str]]:
     return cast(Tuple[str, Optional[str]], robot_split_from_equals(string))

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

@@ -3,6 +3,7 @@
 from typing import (
     Any,
     Callable,
+    ClassVar,
     Dict,
     Iterator,
     Optional,
@@ -37,7 +38,7 @@ def iter_field_values(node: ast.AST) -> Iterator[Any]:
 
 
 class VisitorFinder(ABC):
-    __cls_finder_cache__: Dict[Type[Any], Optional[Callable[..., Any]]]
+    __cls_finder_cache__: ClassVar[Dict[Type[Any], Optional[Callable[..., Any]]]]
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)

tests/robotcode/language_server/robotframework/parts/data/.vscode/settings.json

@@ -13,8 +13,8 @@
         }
     },
     "robotcode.languageServer.extraArgs": [
-        "--verbose",
-        "--debugpy",
+        // "--verbose",
+        // "--debugpy",
         // "--debugpy-wait-for-client",
         // "--log",
         // "--log-level", "INFO",