robotcode-robot 2.1.0__tar.gz → 2.2.0__tar.gz

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-robot
-Version: 2.1.0
+Version: 2.2.0
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode

robotcode_robot-2.2.0/src/robotcode/robot/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.2.0"

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/src/robotcode/robot/diagnostics/document_cache_helper.py

@@ -173,8 +173,8 @@ class DocumentsCacheHelper:
 
     def get_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
         if data_only:
-            return document.get_cache(self.__get_tokens_data_only)
-        return document.get_cache(self.__get_tokens)
+            return self.__get_tokens_data_only(document)
+        return self.__get_tokens(document)
 
     def __get_tokens_data_only(self, document: TextDocument) -> List[Token]:
         document_type = self.get_document_type(document)
@@ -199,6 +199,12 @@ class DocumentsCacheHelper:
         raise UnknownFileTypeError(str(document.uri))
 
     def get_general_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
+        if document.version is None:
+            if data_only:
+                return self.__get_general_tokens_data_only(document)
+
+            return self.__get_general_tokens(document)
+
         if data_only:
             return document.get_cache(self.__get_general_tokens_data_only)
         return document.get_cache(self.__get_general_tokens)
@@ -282,6 +288,12 @@ class DocumentsCacheHelper:
         return get(document.text())
 
     def get_resource_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
+        if document.version is None:
+            if data_only:
+                return self.__get_resource_tokens_data_only(document)
+
+            return self.__get_resource_tokens(document)
+
         if data_only:
             return document.get_cache(self.__get_resource_tokens_data_only)
 
@@ -306,6 +318,12 @@ class DocumentsCacheHelper:
         return self.__get_tokens_internal(document, get)
 
     def get_init_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
+        if document.version is None:
+            if data_only:
+                return self.__get_init_tokens_data_only(document)
+
+            return self.__get_init_tokens(document)
+
         if data_only:
             return document.get_cache(self.__get_init_tokens_data_only)
         return document.get_cache(self.__get_init_tokens)
@@ -363,11 +381,15 @@ class DocumentsCacheHelper:
         return cast(ast.AST, model)
 
     def get_general_model(self, document: TextDocument, data_only: bool = True) -> ast.AST:
+        if document.version is None:
+            if data_only:
+                return self.__get_general_model_data_only(document, self.get_general_tokens(document, True))
+
+            return self.__get_general_model(document, self.get_general_tokens(document))
+
         if data_only:
-            return document.get_cache(
-                self.__get_general_model_data_only,
-                self.get_general_tokens(document, True),
-            )
+            return document.get_cache(self.__get_general_model_data_only, self.get_general_tokens(document, True))
+
         return document.get_cache(self.__get_general_model, self.get_general_tokens(document))
 
     def __get_general_model_data_only(self, document: TextDocument, tokens: Iterable[Any]) -> ast.AST:
@@ -377,6 +399,12 @@ class DocumentsCacheHelper:
         return self.__get_model(document, tokens, DocumentType.GENERAL)
 
     def get_resource_model(self, document: TextDocument, data_only: bool = True) -> ast.AST:
+        if document.version is None:
+            if data_only:
+                return self.__get_resource_model_data_only(document, self.get_resource_tokens(document, True))
+
+            return self.__get_resource_model(document, self.get_resource_tokens(document))
+
         if data_only:
             return document.get_cache(
                 self.__get_resource_model_data_only,
@@ -392,11 +420,15 @@ class DocumentsCacheHelper:
         return self.__get_model(document, tokens, DocumentType.RESOURCE)
 
     def get_init_model(self, document: TextDocument, data_only: bool = True) -> ast.AST:
+        if document.version is None:
+            if data_only:
+                return self.__get_init_model_data_only(document, self.get_init_tokens(document, True))
+
+            return self.__get_init_model(document, self.get_init_tokens(document))
+
         if data_only:
-            return document.get_cache(
-                self.__get_init_model_data_only,
-                self.get_init_tokens(document, True),
-            )
+            return document.get_cache(self.__get_init_model_data_only, self.get_init_tokens(document, True))
+
         return document.get_cache(self.__get_init_model, self.get_init_tokens(document))
 
     def __get_init_model_data_only(self, document: TextDocument, tokens: Iterable[Any]) -> ast.AST:
@@ -406,19 +438,14 @@ class DocumentsCacheHelper:
         return self.__get_model(document, tokens, DocumentType.INIT)
 
     def get_namespace(self, document: TextDocument) -> Namespace:
-        return document.get_cache(self.__get_namespace)
-
-    def __get_namespace(self, document: TextDocument) -> Namespace:
         document_type = self.get_document_type(document)
 
         if document_type == DocumentType.INIT:
             return self.get_init_namespace(document)
         if document_type == DocumentType.RESOURCE:
             return self.get_resource_namespace(document)
-        if document_type == DocumentType.GENERAL:
-            return self.get_general_namespace(document)
 
-        return self.__get_namespace_for_document_type(document, document_type)
+        return self.get_general_namespace(document)
 
     def get_resource_namespace(self, document: TextDocument) -> Namespace:
         return document.get_cache(self.__get_resource_namespace)
@@ -450,7 +477,6 @@ class DocumentsCacheHelper:
             document.remove_cache_entry(self.__get_general_namespace)
             document.remove_cache_entry(self.__get_init_namespace)
             document.remove_cache_entry(self.__get_resource_namespace)
-            document.remove_cache_entry(self.__get_namespace)
 
             self.namespace_invalidated(self, sender)
 

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/src/robotcode/robot/diagnostics/entities.py

@@ -1,20 +1,13 @@
-import functools
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Generic,
     List,
     Optional,
     Tuple,
-    TypeVar,
-    cast,
 )
 
-from typing_extensions import Concatenate, ParamSpec
-
 from robot.parsing.lexer.tokens import Token
 from robotcode.core.lsp.types import Position, Range
 
@@ -24,59 +17,8 @@ from ..utils.variables import VariableMatcher, search_variable
 if TYPE_CHECKING:
     from robotcode.robot.diagnostics.library_doc import KeywordDoc, LibraryDoc
 
-_F = TypeVar("_F", bound=Callable[..., Any])
-
-
-_NOT_SET = object()
-
-
-def single_call(func: _F) -> _F:
-    name = f"__single_result_{func.__name__}__"
-
-    def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
-        result = self.__dict__.get(name, _NOT_SET)
-        if result is _NOT_SET:
-            result = func(self, *args, **kwargs)
-            self.__dict__[name] = result
-        return result
-
-    return cast(_F, wrapper)
-
-
-P = ParamSpec("P")
-R = TypeVar("R")
 
-
-class cached_method(Generic[P, R]):  # noqa: N801
-    def __init__(
-        self, func: Optional[Callable[Concatenate[Any, P], R]] = None, *, maxsize: Optional[int] = None
-    ) -> None:
-        self.func: Optional[Callable[Concatenate[Any, P], R]] = func
-        self._maxsize = maxsize
-        self.cache_name: Optional[str] = None
-        if func is not None:
-            functools.update_wrapper(self, func)
-
-    def __set_name__(self, owner: type, name: str) -> None:
-        self.cache_name = f"__cached_{owner.__name__}_{name}"
-
-    def __call__(self, func: Callable[Concatenate[Any, P], R]) -> "cached_method[P, R]":
-        self.func = func
-        functools.update_wrapper(self, func)
-        return self
-
-    def __get__(self, instance: Any, owner: Optional[type] = None) -> Callable[P, R]:
-        cached = instance.__dict__.get(self.cache_name, _NOT_SET)
-        if cached is _NOT_SET:
-            assert self.func is not None
-
-            bound_method = self.func.__get__(instance, owner)
-            cached = functools.lru_cache(maxsize=self._maxsize)(bound_method)
-            instance.__dict__[self.cache_name] = cached
-        return cast(Callable[P, R], cached)
-
-
-@dataclass
+@dataclass(slots=True)
 class SourceEntity:
     line_no: int
     col_offset: int
@@ -91,7 +33,6 @@ class SourceEntity:
             end=Position(line=self.end_line_no - 1, character=self.end_col_offset),
         )
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -104,7 +45,7 @@ class SourceEntity:
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class Import(SourceEntity):
     name: Optional[str]
     name_token: Optional[Token]
@@ -123,7 +64,7 @@ class Import(SourceEntity):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class LibraryImport(Import):
     args: Tuple[str, ...] = ()
     alias: Optional[str] = None
@@ -142,23 +83,20 @@ class LibraryImport(Import):
             ),
         )
 
-    @single_call
     def __hash__(self) -> int:
         return hash((type(self), self.name, self.args, self.alias))
 
 
-@dataclass
+@dataclass(slots=True)
 class ResourceImport(Import):
-    @single_call
     def __hash__(self) -> int:
         return hash((type(self), self.name))
 
 
-@dataclass
+@dataclass(slots=True)
 class VariablesImport(Import):
     args: Tuple[str, ...] = ()
 
-    @single_call
     def __hash__(self) -> int:
         return hash((type(self), self.name, self.args))
 
@@ -168,6 +106,7 @@ class VariableDefinitionType(Enum):
     LOCAL_VARIABLE = "local variable"
     TEST_VARIABLE = "test variable"
     ARGUMENT = "argument"
+    LIBRARY_ARGUMENT = "library argument"
     GLOBAL_VARIABLE = "global variable"
     COMMAND_LINE_VARIABLE = "global variable [command line]"
     BUILTIN_VARIABLE = "builtin variable"
@@ -176,7 +115,7 @@ class VariableDefinitionType(Enum):
     VARIABLE_NOT_FOUND = "variable not found"
 
 
-@dataclass
+@dataclass(slots=True)
 class VariableDefinition(SourceEntity):
     name: str
     name_token: Optional[Token]  # TODO: this is not needed anymore, but kept for compatibility
@@ -190,19 +129,18 @@ class VariableDefinition(SourceEntity):
     value_is_native: bool = field(default=False, compare=False)
     value_type: Optional[str] = field(default=None, compare=False)
 
-    @functools.cached_property
+    @property
     def matcher(self) -> VariableMatcher:
         return search_variable(self.name)
 
-    @functools.cached_property
+    @property
     def convertable_name(self) -> str:
         m = self.matcher
         value_type = f": {self.value_type}" if self.value_type else ""
         return f"{m.identifier}{{{m.base.strip()}{value_type}}}"
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.range, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
     @property
     def name_range(self) -> Range:
@@ -219,80 +157,74 @@ class VariableDefinition(SourceEntity):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class TestVariableDefinition(VariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.TEST_VARIABLE
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.range, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class LocalVariableDefinition(VariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.LOCAL_VARIABLE
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.range, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class GlobalVariableDefinition(VariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.GLOBAL_VARIABLE
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.range, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class BuiltInVariableDefinition(GlobalVariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.BUILTIN_VARIABLE
     resolvable: bool = True
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, None, None))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class CommandLineVariableDefinition(GlobalVariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.COMMAND_LINE_VARIABLE
     resolvable: bool = True
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.range, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class ArgumentDefinition(LocalVariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.ARGUMENT
     keyword_doc: Optional["KeywordDoc"] = field(default=None, compare=False, metadata={"nosave": True})
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.range, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class EmbeddedArgumentDefinition(ArgumentDefinition):
     pattern: Optional[str] = field(default=None, compare=False)
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.range, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class LibraryArgumentDefinition(ArgumentDefinition):
-    @single_call
+    type: VariableDefinitionType = VariableDefinitionType.LIBRARY_ARGUMENT
+
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.range, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass(frozen=True, eq=False, repr=False)
+@dataclass(slots=True, frozen=True, eq=False, repr=False)
 class NativeValue:
     value: Any
 
@@ -303,39 +235,36 @@ class NativeValue:
         return str(self.value)
 
 
-@dataclass
+@dataclass(slots=True)
 class ImportedVariableDefinition(VariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.IMPORTED_VARIABLE
     value: Optional[NativeValue] = field(default=None, compare=False)
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type, self.source))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class EnvironmentVariableDefinition(VariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.ENVIRONMENT_VARIABLE
     resolvable: bool = True
 
     default_value: Any = field(default=None, compare=False)
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class VariableNotFoundDefinition(VariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.VARIABLE_NOT_FOUND
     resolvable: bool = False
 
-    @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type))
+        return hash((self.type, self.name, self.source, self.range))
 
 
-@dataclass
+@dataclass(slots=True)
 class LibraryEntry:
     name: str
     import_name: str
@@ -354,7 +283,6 @@ class LibraryEntry:
             result += f"  WITH NAME  {self.alias}"
         return result
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -370,12 +298,11 @@ class LibraryEntry:
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class ResourceEntry(LibraryEntry):
     imports: List[Import] = field(default_factory=list, compare=False)
     variables: List[VariableDefinition] = field(default_factory=list, compare=False)
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -388,11 +315,10 @@ class ResourceEntry(LibraryEntry):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class VariablesEntry(LibraryEntry):
     variables: List[ImportedVariableDefinition] = field(default_factory=list, compare=False)
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -406,11 +332,10 @@ class VariablesEntry(LibraryEntry):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class TestCaseDefinition(SourceEntity):
     name: str
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -424,11 +349,10 @@ class TestCaseDefinition(SourceEntity):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class TagDefinition(SourceEntity):
     name: str
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/src/robotcode/robot/diagnostics/keyword_finder.py

@@ -1,5 +1,6 @@
 import functools
 import re
+import weakref
 from itertools import chain
 from typing import TYPE_CHECKING, Dict, Iterable, Iterator, List, NamedTuple, Optional, Sequence, Tuple
 
@@ -40,7 +41,7 @@ DEFAULT_BDD_PREFIXES = {"Given ", "When ", "Then ", "And ", "But "}
 
 class KeywordFinder:
     def __init__(self, namespace: "Namespace") -> None:
-        self._namespace = namespace
+        self._namespace: "Namespace" = weakref.proxy(namespace)
 
         self.diagnostics: List[DiagnosticsEntry] = []
         self.result_bdd_prefix: Optional[str] = None

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/src/robotcode/robot/diagnostics/library_doc.py

@@ -80,8 +80,6 @@ from .entities import (
     LibraryArgumentDefinition,
     NativeValue,
     SourceEntity,
-    cached_method,
-    single_call,
 )
 
 if get_robot_version() < (7, 0):
@@ -202,7 +200,7 @@ if get_robot_version() >= (6, 0):
     # monkey patch robot framework for performance reasons
     _old_from_name = EmbeddedArguments.from_name
 
-    @functools.lru_cache(maxsize=8192)
+    @functools.lru_cache(maxsize=1024)
     def _new_from_name(name: str) -> EmbeddedArguments:
         return _old_from_name(name)
 
@@ -225,7 +223,7 @@ if get_robot_version() >= (6, 0):
 
 else:
 
-    @functools.lru_cache(maxsize=8192)
+    @functools.lru_cache(maxsize=1024)
     def _get_embedded_arguments(name: str) -> Any:
         try:
             return EmbeddedArguments(name)
@@ -290,7 +288,6 @@ class KeywordMatcher:
 
         return self.normalized_name == (normalize_namespace(o) if self._is_namespace else normalize(o))
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -329,20 +326,20 @@ class TypeDocType(Enum):
     STANDARD = "Standard"
 
 
-@dataclass
+@dataclass(slots=True)
 class TypedDictItem:
     key: str
     type: str
     required: Optional[bool] = None
 
 
-@dataclass
+@dataclass(slots=True)
 class EnumMember:
     name: str
     value: str
 
 
-@dataclass
+@dataclass(slots=True)
 class TypeDoc:
     type: str
     name: str
@@ -356,7 +353,6 @@ class TypeDoc:
 
     doc_format: str = ROBOT_DOC_FORMAT
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -369,7 +365,6 @@ class TypeDoc:
             )
         )
 
-    @cached_method
     def to_markdown(self, header_level: int = 2, only_doc: bool = False) -> str:
         result = ""
 
@@ -406,13 +401,13 @@ class TypeDoc:
         return result
 
 
-@dataclass
+@dataclass(slots=True)
 class SourceAndLineInfo:
     source: str
     line_no: int
 
 
-@dataclass
+@dataclass(slots=True)
 class Error:
     message: str
     type_name: str
@@ -453,7 +448,7 @@ def robot_arg_repr(arg: Any) -> Optional[str]:
     return str(robot_arg.default_repr)
 
 
-@dataclass
+@dataclass(slots=True)
 class ArgumentInfo:
     name: str
     str_repr: str
@@ -486,7 +481,6 @@ class ArgumentInfo:
     def __str__(self) -> str:
         return self.signature()
 
-    @cached_method
     def signature(self, add_types: bool = True) -> str:
         prefix = ""
         if self.kind == KeywordArgumentKind.POSITIONAL_ONLY_MARKER:
@@ -519,7 +513,7 @@ class ArgumentInfo:
 DEPRECATED_PATTERN = re.compile(r"^\*DEPRECATED(?P<message>.*)\*(?P<doc>.*)")
 
 
-@dataclass
+@dataclass(slots=True)
 class ArgumentSpec:
     name: Optional[str]
     type: str
@@ -560,7 +554,7 @@ class ArgumentSpec:
     ) -> Tuple[List[Any], List[Tuple[str, Any]]]:
         if not hasattr(self, "__robot_arguments"):
             if get_robot_version() < (7, 0):
-                self.__robot_arguments = RobotArgumentSpec(
+                __robot_arguments = RobotArgumentSpec(
                     self.name,
                     self.type,
                     self.positional_only,
@@ -572,7 +566,7 @@ class ArgumentSpec:
                     None,
                 )
             else:
-                self.__robot_arguments = RobotArgumentSpec(
+                __robot_arguments = RobotArgumentSpec(
                     self.name,
                     self.type,
                     self.positional_only,
@@ -584,18 +578,18 @@ class ArgumentSpec:
                     self.embedded,
                     None,
                 )
-        self.__robot_arguments.name = self.name
+        __robot_arguments.name = self.name
         if validate:
             if get_robot_version() < (7, 0):
                 resolver = ArgumentResolver(
-                    self.__robot_arguments,
+                    __robot_arguments,
                     resolve_named=resolve_named,
                     resolve_variables_until=resolve_variables_until,
                     dict_to_kwargs=dict_to_kwargs,
                 )
             else:
                 resolver = ArgumentResolver(
-                    self.__robot_arguments,
+                    __robot_arguments,
                     resolve_named=resolve_named,
                     resolve_args_until=resolve_variables_until,
                     dict_to_kwargs=dict_to_kwargs,
@@ -609,18 +603,18 @@ class ArgumentSpec:
             def _raise_positional_after_named(self) -> None:
                 pass
 
-        positional, named = MyNamedArgumentResolver(self.__robot_arguments).resolve(arguments, variables)
+        positional, named = MyNamedArgumentResolver(__robot_arguments).resolve(arguments, variables)
         if get_robot_version() < (7, 0):
             positional, named = ArgumentsVariableReplacer(resolve_variables_until).replace(positional, named, variables)
         else:
-            positional, named = ArgumentsVariableReplacer(self.__robot_arguments, resolve_variables_until).replace(
+            positional, named = ArgumentsVariableReplacer(__robot_arguments, resolve_variables_until).replace(
                 positional, named, variables
             )
-        positional, named = DictToKwargs(self.__robot_arguments, dict_to_kwargs).handle(positional, named)
+        positional, named = DictToKwargs(__robot_arguments, dict_to_kwargs).handle(positional, named)
         return positional, named
 
 
-@dataclass
+@dataclass(slots=True)
 class KeywordDoc(SourceEntity):
     name: str = ""
     name_token: Optional[Token] = field(default=None, compare=False)
@@ -673,15 +667,15 @@ class KeywordDoc(SourceEntity):
     def __str__(self) -> str:
         return f"{self.name}({', '.join(str(arg) for arg in self.arguments)})"
 
-    @functools.cached_property
+    @property
     def is_embedded(self) -> bool:
         return self.matcher.embedded_arguments is not None
 
-    @functools.cached_property
+    @property
     def matcher(self) -> KeywordMatcher:
         return KeywordMatcher(self.name)
 
-    @functools.cached_property
+    @property
     def is_deprecated(self) -> bool:
         return self.deprecated or DEPRECATED_PATTERN.match(self.doc) is not None
 
@@ -693,31 +687,31 @@ class KeywordDoc(SourceEntity):
     def is_library_keyword(self) -> bool:
         return self.libtype == "LIBRARY"
 
-    @functools.cached_property
+    @property
     def deprecated_message(self) -> str:
         if (m := DEPRECATED_PATTERN.match(self.doc)) is not None:
             return m.group("message").strip()
         return ""
 
-    @functools.cached_property
+    @property
     def name_range(self) -> Range:
         if self.name_token is not None:
             return range_from_token(self.name_token)
 
         return Range.invalid()
 
-    @functools.cached_property
+    @property
     def normalized_tags(self) -> List[str]:
         return [normalize(tag) for tag in self.tags]
 
-    @functools.cached_property
+    @property
     def is_private(self) -> bool:
         if get_robot_version() < (6, 0):
             return False
 
         return "robot:private" in self.normalized_tags
 
-    @functools.cached_property
+    @property
     def range(self) -> Range:
         if self.name_token is not None:
             return range_from_token(self.name_token)
@@ -733,7 +727,6 @@ class KeywordDoc(SourceEntity):
             ),
         )
 
-    @cached_method
     def to_markdown(
         self,
         add_signature: bool = True,
@@ -829,7 +822,7 @@ class KeywordDoc(SourceEntity):
 
         return result
 
-    @functools.cached_property
+    @property
     def signature(self) -> str:
         return (
             f'({self.type}) "{self.name}": ('
@@ -845,7 +838,6 @@ class KeywordDoc(SourceEntity):
             + ")"
         )
 
-    @cached_method
     def parameter_signature(self, full_signatures: Optional[Sequence[int]] = None) -> str:
         return (
             "("
@@ -889,7 +881,6 @@ class KeywordDoc(SourceEntity):
     def is_run_keywords(self) -> bool:
         return self.libname == BUILTIN_LIBRARY_NAME and self.name == RUN_KEYWORDS_NAME
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -922,7 +913,7 @@ class KeywordError(Exception):
         self.multiple_keywords = multiple_keywords
 
 
-@dataclass
+@dataclass(slots=True)
 class KeywordStore:
     source: Optional[str] = None
     source_type: Optional[str] = None
@@ -989,7 +980,7 @@ class KeywordStore:
         return (v for v in self.keywords if v.matcher.match_string(key))
 
 
-@dataclass
+@dataclass(slots=True)
 class ModuleSpec:
     name: str
     origin: Optional[str]
@@ -1010,7 +1001,7 @@ RE_INLINE_LINK = re.compile(r"([\`])((?:\1|.)+?)\1", re.VERBOSE)
 RE_HEADERS = re.compile(r"^(#{2,9})\s+(\S.*)$", re.MULTILINE)
 
 
-@dataclass
+@dataclass(slots=True)
 class LibraryDoc:
     name: str = ""
     doc: str = field(default="", compare=False)
@@ -1062,7 +1053,6 @@ class LibraryDoc:
         self._update_keywords(self._inits)
         self._update_keywords(self._keywords)
 
-    @single_call
     def __hash__(self) -> int:
         return hash(
             (
@@ -1108,7 +1098,6 @@ class LibraryDoc:
             ),
         )
 
-    @cached_method
     def to_markdown(
         self,
         add_signature: bool = True,
@@ -1258,21 +1247,20 @@ def var_repr(value: Any) -> str:
     return "${{ " + repr(value) + " }}"
 
 
-@dataclass
+@dataclass(slots=True)
 class VariablesDoc(LibraryDoc):
     type: str = "VARIABLES"
     scope: str = "GLOBAL"
 
     variables: List[ImportedVariableDefinition] = field(default_factory=list)
 
-    @cached_method
     def to_markdown(
         self,
         add_signature: bool = True,
         only_doc: bool = True,
         header_level: int = 2,
     ) -> str:
-        result = super().to_markdown(add_signature, only_doc, header_level)
+        result = super(VariablesDoc, self).to_markdown(add_signature, only_doc, header_level)
 
         if self.variables:
             result += "\n---\n\n"
@@ -1291,12 +1279,12 @@ class VariablesDoc(LibraryDoc):
         return result
 
 
-@functools.lru_cache(maxsize=8192)
+@functools.lru_cache(maxsize=1024)
 def is_library_by_path(path: str) -> bool:
     return path.lower().endswith((".py", "/", os.sep))
 
 
-@functools.lru_cache(maxsize=8192)
+@functools.lru_cache(maxsize=1024)
 def is_variables_by_path(path: str) -> bool:
     if get_robot_version() >= (6, 1):
         return path.lower().endswith((".py", ".yml", ".yaml", ".json", "/", os.sep))
@@ -1492,7 +1480,7 @@ def error_from_exception(
     )
 
 
-@dataclass
+@dataclass(slots=True)
 class _Variable:
     name: str
     value: Iterable[str]

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/src/robotcode/robot/diagnostics/namespace.py

@@ -757,14 +757,14 @@ class Namespace:
         self._suite_variables: Optional[Dict[str, Any]] = None
         self._suite_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
 
-        self._diagnostics: List[Diagnostic] = []
-        self._keyword_references: Dict[KeywordDoc, Set[Location]] = {}
-        self._variable_references: Dict[VariableDefinition, Set[Location]] = {}
-        self._local_variable_assignments: Dict[VariableDefinition, Set[Range]] = {}
-        self._namespace_references: Dict[LibraryEntry, Set[Location]] = {}
+        self._diagnostics: Optional[List[Diagnostic]] = None
+        self._keyword_references: Optional[Dict[KeywordDoc, Set[Location]]] = None
+        self._variable_references: Optional[Dict[VariableDefinition, Set[Location]]] = None
+        self._local_variable_assignments: Optional[Dict[VariableDefinition, Set[Range]]] = None
+        self._namespace_references: Optional[Dict[LibraryEntry, Set[Location]]] = None
 
-        self._test_case_definitions: List[TestCaseDefinition] = []
-        self._tag_definitions: List[TagDefinition] = []
+        self._test_case_definitions: Optional[List[TestCaseDefinition]] = None
+        self._tag_definitions: Optional[List[TagDefinition]] = None
 
         self._imported_keywords: Optional[List[KeywordDoc]] = None
         self._imported_keywords_lock = RLock(default_timeout=120, name="Namespace.imported_keywords")
@@ -879,47 +879,53 @@ class Namespace:
 
     @_logger.call
     def get_diagnostics(self) -> List[Diagnostic]:
-        self.ensure_initialized()
+        if self._diagnostics is None:
+            self.ensure_initialized()
 
-        self.analyze()
+            self.analyze()
 
-        return self._diagnostics
+        return self._diagnostics if self._diagnostics is not None else []
 
     @_logger.call
     def get_keyword_references(self) -> Dict[KeywordDoc, Set[Location]]:
-        self.ensure_initialized()
+        if self._keyword_references is None:
+            self.ensure_initialized()
 
-        self.analyze()
+            self.analyze()
 
-        return self._keyword_references
+        return self._keyword_references if self._keyword_references is not None else {}
 
     def get_variable_references(self) -> Dict[VariableDefinition, Set[Location]]:
-        self.ensure_initialized()
+        if self._variable_references is None:
+            self.ensure_initialized()
 
-        self.analyze()
+            self.analyze()
 
-        return self._variable_references
+        return self._variable_references if self._variable_references is not None else {}
 
     def get_testcase_definitions(self) -> List[TestCaseDefinition]:
-        self.ensure_initialized()
+        if self._test_case_definitions is None:
+            self.ensure_initialized()
 
-        self.analyze()
+            self.analyze()
 
-        return self._test_case_definitions
+        return self._test_case_definitions if self._test_case_definitions is not None else []
 
     def get_local_variable_assignments(self) -> Dict[VariableDefinition, Set[Range]]:
-        self.ensure_initialized()
+        if self._local_variable_assignments is None:
+            self.ensure_initialized()
 
-        self.analyze()
+            self.analyze()
 
-        return self._local_variable_assignments
+        return self._local_variable_assignments if self._local_variable_assignments is not None else {}
 
     def get_namespace_references(self) -> Dict[LibraryEntry, Set[Location]]:
-        self.ensure_initialized()
+        if self._namespace_references is None:
+            self.ensure_initialized()
 
-        self.analyze()
+            self.analyze()
 
-        return self._namespace_references
+        return self._namespace_references if self._namespace_references is not None else {}
 
     def get_import_entries(self) -> Dict[Import, LibraryEntry]:
         self.ensure_initialized()
@@ -1182,7 +1188,6 @@ class Namespace:
     ) -> Dict[VariableMatcher, VariableDefinition]:
         self.ensure_initialized()
 
-        # return {m: v for m, v in self.yield_variables(nodes, position)}
         l = list(self.yield_variables(nodes, position))
         return dict(reversed(l))
 
@@ -1926,6 +1931,9 @@ class Namespace:
         related_information: Optional[List[DiagnosticRelatedInformation]] = None,
         data: Optional[Any] = None,
     ) -> None:
+        if self._diagnostics is None:
+            self._diagnostics = []
+
         self._diagnostics.append(
             Diagnostic(
                 range,
@@ -1953,16 +1961,20 @@ class Namespace:
                 self.ensure_initialized()
 
                 with self._logger.measure_time(lambda: f"analyzing document {self.source}", context_name="analyze"):
-                    try:
-                        result = NamespaceAnalyzer(self.model, self, self.create_finder()).run()
+                    analyzer = NamespaceAnalyzer(self.model, self, self.create_finder())
 
-                        self._diagnostics += result.diagnostics
-                        self._keyword_references = result.keyword_references
-                        self._variable_references = result.variable_references
-                        self._local_variable_assignments = result.local_variable_assignments
-                        self._namespace_references = result.namespace_references
-                        self._test_case_definitions = result.test_case_definitions
-                        self._tag_definitions = result.tag_definitions
+                    try:
+                        analyzer_result = analyzer.run()
+
+                        if self._diagnostics is None:
+                            self._diagnostics = []
+                        self._diagnostics += analyzer_result.diagnostics
+                        self._keyword_references = analyzer_result.keyword_references
+                        self._variable_references = analyzer_result.variable_references
+                        self._local_variable_assignments = analyzer_result.local_variable_assignments
+                        self._namespace_references = analyzer_result.namespace_references
+                        self._test_case_definitions = analyzer_result.test_case_definitions
+                        self._tag_definitions = analyzer_result.tag_definitions
 
                         lib_doc = self.get_library_doc()
 
@@ -1989,6 +2001,7 @@ class Namespace:
                         self._logger.debug("analyzing canceled")
                         raise
                     finally:
+                        del analyzer
                         self._analyzed = not canceled
 
                 self.has_analysed(self)

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/src/robotcode/robot/diagnostics/namespace_analyzer.py

@@ -93,7 +93,7 @@ else:
     from robot.variables.search import VariableMatches
 
 
-@dataclass
+@dataclass(slots=True, frozen=True)
 class AnalyzerResult:
     diagnostics: List[Diagnostic]
     keyword_references: Dict[KeywordDoc, Set[Location]]

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/src/robotcode/robot/utils/match.py

@@ -5,12 +5,12 @@ _transform_table = str.maketrans("", "", "_ ")
 _transform_table_namespace = str.maketrans("", "", " ")
 
 
-@lru_cache(maxsize=8192)
+@lru_cache(maxsize=1024)
 def normalize(text: str) -> str:
     return text.translate(_transform_table).casefold()
 
 
-@lru_cache(maxsize=8192)
+@lru_cache(maxsize=1024)
 def normalize_namespace(text: str) -> str:
     return text.translate(_transform_table_namespace).casefold()
 

{robotcode_robot-2.1.0 → robotcode_robot-2.2.0}/src/robotcode/robot/utils/variables.py

@@ -200,28 +200,28 @@ BUILTIN_VARIABLES = [
 ]
 
 
-@functools.lru_cache(maxsize=8192)
+@functools.lru_cache(maxsize=1024)
 def contains_variable(string: str, identifiers: str = "$@&") -> bool:
     return cast(bool, robot_contains_variable(string, identifiers))
 
 
-@functools.lru_cache(maxsize=8192)
+@functools.lru_cache(maxsize=1024)
 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=8192)
+@functools.lru_cache(maxsize=1024)
 def is_variable(string: str, identifiers: str = "$@&") -> bool:
     return cast(bool, robot_is_variable(string, identifiers))
 
 
-@functools.lru_cache(maxsize=8192)
+@functools.lru_cache(maxsize=1024)
 def search_variable(
     string: str, identifiers: str = "$@&%*", parse_type: bool = False, ignore_errors: bool = False
 ) -> VariableMatcher:
     return VariableMatcher(string, identifiers, parse_type, ignore_errors)
 
 
-@functools.lru_cache(maxsize=8192)
+@functools.lru_cache(maxsize=1024)
 def split_from_equals(string: str) -> Tuple[str, Optional[str]]:
     return cast(Tuple[str, Optional[str]], robot_split_from_equals(string))

robotcode_robot-2.1.0/src/robotcode/robot/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.1.0"