robotcode-robot 0.95.1__tar.gz → 0.95.2__tar.gz

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-robot
-Version: 0.95.1
+Version: 0.95.2
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -26,7 +26,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Requires-Dist: platformdirs<4.2.0,>=3.2.0
-Requires-Dist: robotcode-core==0.95.1
+Requires-Dist: robotcode-core==0.95.2
 Requires-Dist: robotframework>=4.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/pyproject.toml

@@ -29,7 +29,7 @@ dependencies = [
   "robotframework>=4.1.0",
   "tomli>=1.1.0; python_version < '3.11'",
   "platformdirs>=3.2.0,<4.2.0",
-  "robotcode-core==0.95.1",
+  "robotcode-core==0.95.2",
 ]
 dynamic = ["version"]
 

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

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

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/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 @@ class VariableMatcher:
 
         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 @@ class VariableMatcher:
             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:

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/diagnostics/imports_manager.py

@@ -573,12 +573,10 @@ class ImportsManager:
         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 @@ class ImportsManager:
         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 @@ class ImportsManager:
             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

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/diagnostics/keyword_finder.py

@@ -39,9 +39,8 @@ DEFAULT_BDD_PREFIXES = {"Given ", "When ", "Then ", "And ", "But "}
 
 
 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 @@ class KeywordFinder:
             ],
         ] = {}
 
-        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 @@ class KeywordFinder:
     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 @@ class KeywordFinder:
             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 @@ class KeywordFinder:
 
         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 @@ class KeywordFinder:
     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 @@ class KeywordFinder:
             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 @@ class KeywordFinder:
     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 @@ class KeywordFinder:
     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")

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/diagnostics/library_doc.py

@@ -44,7 +44,7 @@ from robot.output.logger import LOGGER
 from robot.output.loggerhelper import AbstractLogger
 from robot.parsing.lexer.tokens import Token
 from robot.parsing.lexer.tokens import Token as RobotToken
-from robot.parsing.model.blocks import Keyword
+from robot.parsing.model.blocks import Keyword, KeywordSection, Section, SettingSection
 from robot.parsing.model.statements import Arguments, KeywordName
 from robot.running.arguments.argumentresolver import ArgumentResolver, DictToKwargs, NamedArgumentResolver
 from robot.running.arguments.argumentresolver import VariableReplacer as ArgumentsVariableReplacer
@@ -64,7 +64,18 @@ from robot.variables.finders import VariableFinder
 from robot.variables.replacer import VariableReplacer
 from robotcode.core.lsp.types import Position, Range
 from robotcode.core.utils.path import normalized_path
-from robotcode.robot.diagnostics.entities import (
+
+from ..utils import get_robot_version
+from ..utils.ast import (
+    cached_isinstance,
+    get_variable_token,
+    range_from_token,
+    strip_variable_token,
+)
+from ..utils.markdownformatter import MarkDownFormatter
+from ..utils.match import normalize, normalize_namespace
+from ..utils.variables import contains_variable
+from .entities import (
     ArgumentDefinition,
     ImportedVariableDefinition,
     LibraryArgumentDefinition,
@@ -72,18 +83,6 @@ from robotcode.robot.diagnostics.entities import (
     SourceEntity,
     single_call,
 )
-from robotcode.robot.utils import get_robot_version
-from robotcode.robot.utils.ast import (
-    cached_isinstance,
-    get_variable_token,
-    iter_nodes,
-    range_from_token,
-    strip_variable_token,
-)
-from robotcode.robot.utils.markdownformatter import MarkDownFormatter
-from robotcode.robot.utils.match import normalize, normalize_namespace
-
-from ..utils.variables import contains_variable
 
 if get_robot_version() < (7, 0):
     from robot.running.handlers import _PythonHandler, _PythonInitHandler  # pyright: ignore[reportMissingImports]
@@ -201,22 +200,36 @@ def convert_from_rest(text: str) -> str:
 
 if get_robot_version() >= (6, 0):
 
-    @functools.lru_cache(maxsize=None)
+    # monkey patch robot framework
+    _old_from_name = EmbeddedArguments.from_name
+
+    @functools.lru_cache(maxsize=8192)
+    def _new_from_name(name: str) -> EmbeddedArguments:
+        return _old_from_name(name)
+
+    EmbeddedArguments.from_name = _new_from_name
+
     def _get_embedded_arguments(name: str) -> Any:
         try:
             return EmbeddedArguments.from_name(name)
         except (VariableError, DataError):
             return ()
 
+    def _match_embedded(embedded_arguments: EmbeddedArguments, name: str) -> bool:
+        return embedded_arguments.match(name) is not None
+
 else:
 
-    @functools.lru_cache(maxsize=None)
+    @functools.lru_cache(maxsize=8192)
     def _get_embedded_arguments(name: str) -> Any:
         try:
             return EmbeddedArguments(name)
         except (VariableError, DataError):
             return ()
 
+    def _match_embedded(embedded_arguments: EmbeddedArguments, name: str) -> bool:
+        return embedded_arguments.name.match(name) is not None
+
 
 def is_embedded_keyword(name: str) -> bool:
     try:
@@ -243,31 +256,20 @@ class KeywordMatcher:
         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))
+            self._normalized_name = normalize_namespace(self.name) if self._is_namespace else normalize(self.name)
 
         return self._normalized_name
 
-    if get_robot_version() >= (6, 0):
-
-        def __match_embedded(self, name: str) -> bool:
-            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 is not None and self.embedded_arguments.name.match(name) is not None
-
     def __eq__(self, o: object) -> bool:
         if type(o) is KeywordMatcher:
             if self._is_namespace != o._is_namespace:
                 return False
 
-            if not self.embedded_arguments:
+            if self.embedded_arguments is not None:
                 return self.normalized_name == o.normalized_name
 
             o = o.name
@@ -275,17 +277,25 @@ class KeywordMatcher:
         if type(o) is not str:
             return False
 
-        if self.embedded_arguments:
-            return self.__match_embedded(o)
+        return self.match_string(o)
 
-        return self.normalized_name == str(normalize_namespace(o) if self._is_namespace else normalize(o))
+    def match_string(self, o: str) -> bool:
+        if self.embedded_arguments is not None:
+            return _match_embedded(self.embedded_arguments, o)
+
+        return self.normalized_name == (normalize_namespace(o) if self._is_namespace else normalize(o))
 
     @single_call
     def __hash__(self) -> int:
         return hash(
-            (self.embedded_arguments.name, tuple(self.embedded_arguments.args))
-            if self.embedded_arguments
-            else (self.normalized_name, self._is_namespace)
+            (
+                self.normalized_name,
+                self._is_namespace,
+                self._can_have_embedded,
+                self.embedded_arguments,
+                self.embedded_arguments.name if self.embedded_arguments else None,
+                self.embedded_arguments.args if self.embedded_arguments else None,
+            )
         )
 
     def __str__(self) -> str:
@@ -612,7 +622,6 @@ class KeywordDoc(SourceEntity):
     libname: Optional[str] = None
     libtype: Optional[str] = None
     longname: Optional[str] = None
-    is_embedded: bool = False
     errors: Optional[List[Error]] = field(default=None, compare=False)
     doc_format: str = ROBOT_DOC_FORMAT
     is_error_handler: bool = False
@@ -661,6 +670,10 @@ class KeywordDoc(SourceEntity):
     def __str__(self) -> str:
         return f"{self.name}({', '.join(str(arg) for arg in self.arguments)})"
 
+    @functools.cached_property
+    def is_embedded(self) -> bool:
+        return self.matcher.embedded_arguments is not None
+
     @functools.cached_property
     def matcher(self) -> KeywordMatcher:
         return KeywordMatcher(self.name)
@@ -690,16 +703,16 @@ class KeywordDoc(SourceEntity):
 
         return Range.invalid()
 
-    @single_call
+    @functools.cached_property
     def normalized_tags(self) -> List[str]:
         return [normalize(tag) for tag in self.tags]
 
-    @single_call
+    @functools.cached_property
     def is_private(self) -> bool:
         if get_robot_version() < (6, 0):
             return False
 
-        return "robot:private" in self.normalized_tags()
+        return "robot:private" in self.normalized_tags
 
     @functools.cached_property
     def range(self) -> Range:
@@ -885,7 +898,6 @@ class KeywordDoc(SourceEntity):
                 self.type,
                 self.libname,
                 self.libtype,
-                self.is_embedded,
                 self.is_initializer,
                 self.is_error_handler,
                 self.doc_format,
@@ -969,7 +981,7 @@ class KeywordStore:
         return list(self.iter_all(key))
 
     def iter_all(self, key: str) -> Iterable[KeywordDoc]:
-        yield from (v for v in self.keywords if v.matcher == key)
+        return (v for v in self.keywords if v.matcher.match_string(key))
 
 
 @dataclass
@@ -1282,12 +1294,12 @@ class VariablesDoc(LibraryDoc):
         return result
 
 
-@functools.lru_cache(maxsize=256)
+@functools.lru_cache(maxsize=8192)
 def is_library_by_path(path: str) -> bool:
     return path.lower().endswith((".py", "/", os.sep))
 
 
-@functools.lru_cache(maxsize=256)
+@functools.lru_cache(maxsize=8192)
 def is_variables_by_path(path: str) -> bool:
     if get_robot_version() >= (6, 1):
         return path.lower().endswith((".py", ".yml", ".yaml", ".json", "/", os.sep))
@@ -2016,7 +2028,6 @@ def get_library_doc(
                             libname=libdoc.name,
                             libtype=libdoc.type,
                             longname=f"{libdoc.name}.{kw[0].name}",
-                            is_embedded=is_embedded_keyword(kw[0].name),
                             doc_format=str(lib.doc_format) or ROBOT_DOC_FORMAT,
                             is_error_handler=kw[1].is_error_handler,
                             error_handler_message=kw[1].error_handler_message,
@@ -2696,133 +2707,146 @@ def complete_variables_import(
     return list(set(result))
 
 
-def get_model_doc(
-    model: ast.AST,
-    source: str,
-    append_model_errors: bool = True,
-) -> LibraryDoc:
-    errors: List[Error] = []
-    keyword_name_nodes: Dict[int, KeywordName] = {}
-    keywords_nodes: Dict[int, Keyword] = {}
-    for node in iter_nodes(model):
-        if cached_isinstance(node, Keyword):
-            node.lineno
-            keywords_nodes[node.lineno] = node
-        if cached_isinstance(node, KeywordName):
-            keyword_name_nodes[node.lineno] = node
-
-        error = getattr(node, "error", None)
-        if error is not None:
-            errors.append(
-                Error(
-                    message=error,
-                    type_name="ModelError",
-                    source=source,
-                    line_no=node.lineno,  # type: ignore
-                )
-            )
-        if append_model_errors:
-            node_errors = getattr(node, "errors", None)
-            if node_errors is not None:
-                for e in node_errors:
-                    errors.append(
-                        Error(
-                            message=e,
-                            type_name="ModelError",
-                            source=source,
-                            line_no=node.lineno,  # type: ignore
-                        )
-                    )
-
-    def get_keyword_name_token_from_line(line: int) -> Optional[Token]:
-        keyword_name = keyword_name_nodes.get(line, None)
-        if keyword_name is None:
-            return None
-        return cast(Token, keyword_name.get_token(RobotToken.KEYWORD_NAME))
+if get_robot_version() < (7, 0):
 
-    def get_argument_definitions_from_line(
-        line: int,
-    ) -> List[ArgumentDefinition]:
-        keyword_node = keywords_nodes.get(line, None)
-        if keyword_node is None:
-            return []
+    class _MyUserLibrary(UserLibrary):
+        current_kw: Any = None
 
-        arguments_node = next(
-            (n for n in ast.walk(keyword_node) if isinstance(n, Arguments)),
-            None,
-        )
-        if arguments_node is None:
-            return []
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            self.errors: List[Error] = []
+            super().__init__(*args, **kwargs)
 
-        args: List[str] = []
-        arguments = arguments_node.get_tokens(RobotToken.ARGUMENT)
-        argument_definitions = []
+        def _log_creating_failed(self, handler: UserErrorHandler, error: BaseException) -> None:
+            err = Error(
+                message=f"Creating keyword '{handler.name}' failed: {error!s}",
+                type_name=type(error).__qualname__,
+                source=self.current_kw.source if self.current_kw is not None else None,
+                line_no=self.current_kw.lineno if self.current_kw is not None else None,
+            )
+            self.errors.append(err)
 
-        for argument_token in (cast(RobotToken, e) for e in arguments):
+        def _create_handler(self, kw: Any) -> Any:
+            self.current_kw = kw
             try:
-                argument = get_variable_token(argument_token)
-
-                if argument is not None and argument.value != "@{}":
-                    if argument.value not in args:
-                        args.append(argument.value)
-                        arg_def = ArgumentDefinition(
-                            name=argument.value,
-                            name_token=strip_variable_token(argument),
-                            line_no=argument.lineno,
-                            col_offset=argument.col_offset,
-                            end_line_no=argument.lineno,
-                            end_col_offset=argument.end_col_offset,
-                            source=source,
-                        )
-                        argument_definitions.append(arg_def)
+                handler = super()._create_handler(kw)
+                handler.errors = None
+            except DataError as e:
+                err = Error(
+                    message=str(e),
+                    type_name=type(e).__qualname__,
+                    source=kw.source,
+                    line_no=kw.lineno,
+                )
+                self.errors.append(err)
 
-            except VariableError:
-                pass
+                handler = UserErrorHandler(e, kw.name, self.name)
+                handler.source = kw.source
+                handler.lineno = kw.lineno
 
-        return argument_definitions
+                handler.errors = [err]
 
-    res = ResourceFile(source=source)
+            return handler
 
-    with LOGGER.cache_only:
-        ResourceBuilder(res).visit(model)
 
-    if get_robot_version() < (7, 0):
+def _get_keyword_name_token_from_line(keyword_name_nodes: Dict[int, KeywordName], line: int) -> Optional[Token]:
+    keyword_name = keyword_name_nodes.get(line, None)
+    if keyword_name is None:
+        return None
+    return cast(Token, keyword_name.get_token(RobotToken.KEYWORD_NAME))
 
-        class MyUserLibrary(UserLibrary):
-            current_kw: Any = None
 
-            def _log_creating_failed(self, handler: UserErrorHandler, error: BaseException) -> None:
-                err = Error(
-                    message=f"Creating keyword '{handler.name}' failed: {error!s}",
-                    type_name=type(error).__qualname__,
-                    source=self.current_kw.source if self.current_kw is not None else None,
-                    line_no=self.current_kw.lineno if self.current_kw is not None else None,
-                )
-                errors.append(err)
+def _get_argument_definitions_from_line(
+    keywords_nodes: Dict[int, Keyword],
+    source: Optional[str],
+    line: int,
+) -> List[ArgumentDefinition]:
+    keyword_node = keywords_nodes.get(line, None)
+    if keyword_node is None:
+        return []
 
-            def _create_handler(self, kw: Any) -> Any:
-                self.current_kw = kw
-                try:
-                    handler = super()._create_handler(kw)
-                    handler.errors = None
-                except DataError as e:
-                    err = Error(
-                        message=str(e),
-                        type_name=type(e).__qualname__,
-                        source=kw.source,
-                        line_no=kw.lineno,
+    arguments_node = next(
+        (n for n in ast.walk(keyword_node) if isinstance(n, Arguments)),
+        None,
+    )
+    if arguments_node is None:
+        return []
+
+    args: List[str] = []
+    arguments = arguments_node.get_tokens(RobotToken.ARGUMENT)
+    argument_definitions = []
+
+    for argument_token in (cast(RobotToken, e) for e in arguments):
+        try:
+            argument = get_variable_token(argument_token)
+
+            if argument is not None and argument.value != "@{}":
+                if argument.value not in args:
+                    args.append(argument.value)
+                    arg_def = ArgumentDefinition(
+                        name=argument.value,
+                        name_token=strip_variable_token(argument),
+                        line_no=argument.lineno,
+                        col_offset=argument.col_offset,
+                        end_line_no=argument.lineno,
+                        end_col_offset=argument.end_col_offset,
+                        source=source,
                     )
-                    errors.append(err)
+                    argument_definitions.append(arg_def)
 
-                    handler = UserErrorHandler(e, kw.name, self.name)
-                    handler.source = kw.source
-                    handler.lineno = kw.lineno
+        except VariableError:
+            pass
 
-                    handler.errors = [err]
+    return argument_definitions
+
+
+class _MyResourceBuilder(ResourceBuilder):
+    def __init__(self, resource: Any) -> None:
+        super().__init__(resource)
+        self.keyword_name_nodes: Dict[int, KeywordName] = {}
+        self.keywords_nodes: Dict[int, Keyword] = {}
+
+    def visit_Section(self, node: Section) -> None:  # noqa: N802
+        if isinstance(node, (SettingSection, KeywordSection)):
+            self.generic_visit(node)
+
+    def visit_Keyword(self, node: Keyword) -> None:  # noqa: N802
+        self.keywords_nodes[node.lineno] = node
+        super().visit_Keyword(node)
+        if node.header is not None:
+            self.keyword_name_nodes[node.lineno] = node.header
+
+
+def _get_kw_errors(kw: Any) -> Any:
+    r = kw.errors if hasattr(kw, "errors") else None
+    if get_robot_version() >= (7, 0) and kw.error:
+        if not r:
+            r = []
+        r.append(
+            Error(
+                message=str(kw.error),
+                type_name="KeywordError",
+                source=kw.source,
+                line_no=kw.lineno,
+            )
+        )
+    return r
 
-                return handler
 
-        lib = MyUserLibrary(res)
+def get_model_doc(
+    model: ast.AST,
+    source: str,
+) -> LibraryDoc:
+    res = ResourceFile(source=source)
+
+    res_builder = _MyResourceBuilder(res)
+    with LOGGER.cache_only:
+        res_builder.visit(model)
+
+    keyword_name_nodes: Dict[int, KeywordName] = res_builder.keyword_name_nodes
+    keywords_nodes: Dict[int, Keyword] = res_builder.keywords_nodes
+
+    if get_robot_version() < (7, 0):
+        lib = _MyUserLibrary(res)
     else:
         lib = res
 
@@ -2833,24 +2857,8 @@ def get_model_doc(
         scope="GLOBAL",
         source=source,
         line_no=1,
-        errors=errors,
     )
 
-    def get_kw_errors(kw: Any) -> Any:
-        r = kw.errors if hasattr(kw, "errors") else None
-        if get_robot_version() >= (7, 0) and kw.error:
-            if not r:
-                r = []
-            r.append(
-                Error(
-                    message=str(kw.error),
-                    type_name="KeywordError",
-                    source=kw.source,
-                    line_no=kw.lineno,
-                )
-            )
-        return r
-
     libdoc.keywords = KeywordStore(
         source=libdoc.name,
         source_type=libdoc.type,
@@ -2861,7 +2869,7 @@ def get_model_doc(
                 doc=kw[0].doc,
                 tags=list(kw[0].tags),
                 source=str(kw[0].source),
-                name_token=get_keyword_name_token_from_line(kw[0].lineno),
+                name_token=_get_keyword_name_token_from_line(keyword_name_nodes, kw[0].lineno),
                 line_no=kw[0].lineno if kw[0].lineno is not None else -1,
                 col_offset=-1,
                 end_col_offset=-1,
@@ -2869,8 +2877,7 @@ def get_model_doc(
                 libname=libdoc.name,
                 libtype=libdoc.type,
                 longname=f"{libdoc.name}.{kw[0].name}",
-                is_embedded=is_embedded_keyword(kw[0].name),
-                errors=get_kw_errors(kw[1]),
+                errors=_get_kw_errors(kw[1]),
                 is_error_handler=isinstance(kw[1], UserErrorHandler),
                 error_handler_message=(
                     str(cast(UserErrorHandler, kw[1]).error) if isinstance(kw[1], UserErrorHandler) else None
@@ -2878,7 +2885,7 @@ def get_model_doc(
                 arguments_spec=ArgumentSpec.from_robot_argument_spec(
                     kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
                 ),
-                argument_definitions=get_argument_definitions_from_line(kw[0].lineno),
+                argument_definitions=_get_argument_definitions_from_line(keywords_nodes, source, kw[0].lineno),
             )
             for kw in [
                 (KeywordDocBuilder(resource=True).build_keyword(lw), lw)

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/diagnostics/namespace.py

@@ -910,11 +910,7 @@ class Namespace:
     def get_library_doc(self) -> LibraryDoc:
         with self._library_doc_lock:
             if self._library_doc is None:
-                self._library_doc = self.imports_manager.get_libdoc_from_model(
-                    self.model,
-                    self.source,
-                    append_model_errors=self.document_type is not None and self.document_type == DocumentType.RESOURCE,
-                )
+                self._library_doc = self.imports_manager.get_libdoc_from_model(self.model, self.source)
 
             return self._library_doc
 
@@ -1887,7 +1883,6 @@ class Namespace:
                                     source=DIAGNOSTICS_SOURCE_NAME,
                                     code=err.type_name,
                                 )
-                    # TODO: implement CancelationToken
                     except CancelledError:
                         canceled = True
                         self._logger.debug("analyzing canceled")
@@ -1904,7 +1899,7 @@ class Namespace:
 
     def create_finder(self) -> "KeywordFinder":
         self.ensure_initialized()
-        return KeywordFinder(self, self.get_library_doc())
+        return KeywordFinder(self)
 
     @_logger.call(condition=lambda self, name, **kwargs: self._finder is not None and name not in self._finder._cache)
     def find_keyword(

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/diagnostics/namespace_analyzer.py

@@ -1,4 +1,5 @@
 import ast
+import functools
 import itertools
 import os
 import token as python_token
@@ -70,7 +71,7 @@ from .entities import (
 )
 from .errors import DIAGNOSTICS_SOURCE_NAME, Error
 from .keyword_finder import KeywordFinder
-from .library_doc import KeywordDoc, is_embedded_keyword
+from .library_doc import KeywordDoc, LibraryDoc, is_embedded_keyword
 from .model_helper import ModelHelper
 
 if TYPE_CHECKING:
@@ -697,7 +698,7 @@ class NamespaceAnalyzer(Visitor):
                         code=Error.RESERVED_KEYWORD,
                     )
 
-                if get_robot_version() >= (6, 0) and result.is_resource_keyword and result.is_private():
+                if get_robot_version() >= (6, 0) and result.is_resource_keyword and result.is_private:
                     if self._namespace.source != result.source:
                         self._append_diagnostics(
                             range=kw_range,
@@ -1042,12 +1043,14 @@ class NamespaceAnalyzer(Visitor):
         if name_token is not None and name_token.value:
             self._analyze_token_variables(name_token, DiagnosticSeverity.HINT)
 
+    @functools.cached_property
+    def _namespace_lib_doc(self) -> LibraryDoc:
+        return self._namespace.get_library_doc()
+
     def visit_Keyword(self, node: Keyword) -> None:  # noqa: N802
         if node.name:
             name_token = node.header.get_token(Token.KEYWORD_NAME)
-            self._current_keyword_doc = ModelHelper.get_keyword_definition_at_token(
-                self._namespace.get_library_doc(), name_token
-            )
+            self._current_keyword_doc = ModelHelper.get_keyword_definition_at_token(self._namespace_lib_doc, name_token)
 
             if self._current_keyword_doc is not None and self._current_keyword_doc not in self._keyword_references:
                 self._keyword_references[self._current_keyword_doc] = set()

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/utils/ast.py

@@ -80,23 +80,23 @@ class FirstAndLastRealStatementFinder(Visitor):
             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(

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/utils/markdownformatter.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 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 @@ class SingleLineFormatter(Formatter):
 
 
 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 @@ class HeaderFormatter(SingleLineFormatter):
 
 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 @@ class LinkFormatter:
 
 
 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 @@ _                          # end of italic
 """,
         re.VERBOSE,
     )
-    _code = re.compile(
+    _code: Final["re.Pattern[str]"] = re.compile(
         r"""
 ( (^|\ ) ["'(]* )          # same as above with _ changed to ``
 ``
@@ -296,7 +296,7 @@ class ListFormatter(Formatter):
 
 
 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 @@ class RulerFormatter(SingleLineFormatter):
 
 
 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

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/utils/match.py

@@ -2,16 +2,17 @@ from functools import lru_cache
 
 _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:

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/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]

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/utils/variables.py

@@ -47,26 +47,26 @@ BUILTIN_VARIABLES = [
 ]
 
 
-@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))

{robotcode_robot-0.95.1 → robotcode_robot-0.95.2}/src/robotcode/robot/utils/visitor.py

@@ -3,6 +3,7 @@ from abc import ABC
 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)

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

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