robotcode-robot 0.94.0__py3-none-any.whl → 0.95.1__py3-none-any.whl

robotcode/robot/diagnostics/library_doc.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+import functools
 import hashlib
 import importlib
 import importlib.util
@@ -61,7 +62,6 @@ from robot.variables import Variables
 from robot.variables.filesetter import PythonImporter, YamlImporter
 from robot.variables.finders import VariableFinder
 from robot.variables.replacer import VariableReplacer
-from robot.variables.search import contains_variable
 from robotcode.core.lsp.types import Position, Range
 from robotcode.core.utils.path import normalized_path
 from robotcode.robot.diagnostics.entities import (
@@ -76,12 +76,14 @@ 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 robotcode.robot.utils.stubs import HasError, HasErrors
+
+from ..utils.variables import contains_variable
 
 if get_robot_version() < (7, 0):
     from robot.running.handlers import _PythonHandler, _PythonInitHandler  # pyright: ignore[reportMissingImports]
@@ -197,14 +199,29 @@ def convert_from_rest(text: str) -> str:
     return text
 
 
+if get_robot_version() >= (6, 0):
+
+    @functools.lru_cache(maxsize=None)
+    def _get_embedded_arguments(name: str) -> Any:
+        try:
+            return EmbeddedArguments.from_name(name)
+        except (VariableError, DataError):
+            return ()
+
+else:
+
+    @functools.lru_cache(maxsize=None)
+    def _get_embedded_arguments(name: str) -> Any:
+        try:
+            return EmbeddedArguments(name)
+        except (VariableError, DataError):
+            return ()
+
+
 def is_embedded_keyword(name: str) -> bool:
     try:
-        if get_robot_version() >= (6, 0):
-            if EmbeddedArguments.from_name(name):
-                return True
-        else:
-            if EmbeddedArguments(name):
-                return True
+        if _get_embedded_arguments(name):
+            return True
     except (VariableError, DataError):
         return True
 
@@ -222,7 +239,11 @@ class KeywordMatcher:
         self._can_have_embedded = can_have_embedded and not is_namespace
         self._is_namespace = is_namespace
         self._normalized_name: Optional[str] = None
-        self._embedded_arguments: Any = None
+
+        self.embedded_arguments: Optional[EmbeddedArguments] = (
+            _get_embedded_arguments(self.name) or None if self._can_have_embedded else None
+        )
+        self._match_cache: Dict[str, bool] = {}
 
     @property
     def normalized_name(self) -> str:
@@ -231,24 +252,18 @@ class KeywordMatcher:
 
         return self._normalized_name
 
-    @property
-    def embedded_arguments(self) -> Any:
-        if self._embedded_arguments is None:
-            if self._can_have_embedded:
-                try:
-                    if get_robot_version() >= (6, 0):
-                        self._embedded_arguments = EmbeddedArguments.from_name(self.name)
-                    else:
-                        self._embedded_arguments = EmbeddedArguments(self.name)
-                except (VariableError, DataError):
-                    self._embedded_arguments = ()
-            else:
-                self._embedded_arguments = ()
+    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
 
-        return self._embedded_arguments
+    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 cached_isinstance(o, KeywordMatcher):
+        if type(o) is KeywordMatcher:
             if self._is_namespace != o._is_namespace:
                 return False
 
@@ -257,14 +272,11 @@ class KeywordMatcher:
 
             o = o.name
 
-        if not cached_isinstance(o, str):
+        if type(o) is not str:
             return False
 
         if self.embedded_arguments:
-            if get_robot_version() >= (6, 0):
-                return self.embedded_arguments.match(o) is not None
-
-            return self.embedded_arguments.name.match(o) is not None
+            return self.__match_embedded(o)
 
         return self.normalized_name == str(normalize_namespace(o) if self._is_namespace else normalize(o))
 
@@ -649,13 +661,11 @@ class KeywordDoc(SourceEntity):
     def __str__(self) -> str:
         return f"{self.name}({', '.join(str(arg) for arg in self.arguments)})"
 
-    @property
+    @functools.cached_property
     def matcher(self) -> KeywordMatcher:
-        if not hasattr(self, "__matcher"):
-            self.__matcher = KeywordMatcher(self.name)
-        return self.__matcher
+        return KeywordMatcher(self.name)
 
-    @property
+    @functools.cached_property
     def is_deprecated(self) -> bool:
         return self.deprecated or DEPRECATED_PATTERN.match(self.doc) is not None
 
@@ -667,13 +677,13 @@ class KeywordDoc(SourceEntity):
     def is_library_keyword(self) -> bool:
         return self.libtype == "LIBRARY"
 
-    @property
+    @functools.cached_property
     def deprecated_message(self) -> str:
         if (m := DEPRECATED_PATTERN.match(self.doc)) is not None:
             return m.group("message").strip()
         return ""
 
-    @property
+    @functools.cached_property
     def name_range(self) -> Range:
         if self.name_token is not None:
             return range_from_token(self.name_token)
@@ -691,7 +701,7 @@ class KeywordDoc(SourceEntity):
 
         return "robot:private" in self.normalized_tags()
 
-    @property
+    @functools.cached_property
     def range(self) -> Range:
         if self.name_token is not None:
             return range_from_token(self.name_token)
@@ -802,7 +812,7 @@ class KeywordDoc(SourceEntity):
 
         return result
 
-    @property
+    @functools.cached_property
     def signature(self) -> str:
         return (
             f'({self.type}) "{self.name}": ('
@@ -901,20 +911,13 @@ class KeywordStore:
     source_type: Optional[str] = None
     keywords: List[KeywordDoc] = field(default_factory=list)
 
-    @property
-    def _matchers(self) -> Dict[KeywordMatcher, KeywordDoc]:
-        if not hasattr(self, "__matchers"):
-            self.__matchers = {v.matcher: v for v in self.keywords}
-        return self.__matchers
-
     def __getitem__(self, key: str) -> KeywordDoc:
-        key_matcher = KeywordMatcher(key)
-        items = [(k, v) for k, v in self._matchers.items() if k == key_matcher]
+        items = [v for v in self.keywords if v.matcher == key]
 
         if not items:
             raise KeyError
         if len(items) == 1:
-            return items[0][1]
+            return items[0]
 
         if self.source and self.source_type:
             file_info = ""
@@ -929,16 +932,14 @@ class KeywordStore:
         else:
             file_info = "File"
         error = [f"{file_info} contains multiple keywords matching name '{key}':"]
-        names = sorted(k.name for k, v in items)
+        names = sorted(v.name for v in items)
         raise KeywordError(
             "\n    ".join(error + names),
-            multiple_keywords=[v for _, v in items],
+            multiple_keywords=[v for v in items],
         )
 
     def __contains__(self, _x: object) -> bool:
-        if not isinstance(_x, KeywordMatcher):
-            _x = KeywordMatcher(str(_x))
-        return any(k == _x for k in self._matchers.keys())
+        return any(v.matcher == _x for v in self.keywords)
 
     def __len__(self) -> int:
         return len(self.keywords)
@@ -968,8 +969,7 @@ class KeywordStore:
         return list(self.iter_all(key))
 
     def iter_all(self, key: str) -> Iterable[KeywordDoc]:
-        key_matcher = KeywordMatcher(key)
-        yield from (v for k, v in self._matchers.items() if k == key_matcher)
+        yield from (v for v in self.keywords if v.matcher == key)
 
 
 @dataclass
@@ -1282,10 +1282,12 @@ class VariablesDoc(LibraryDoc):
         return result
 
 
+@functools.lru_cache(maxsize=256)
 def is_library_by_path(path: str) -> bool:
     return path.lower().endswith((".py", "/", os.sep))
 
 
+@functools.lru_cache(maxsize=256)
 def is_variables_by_path(path: str) -> bool:
     if get_robot_version() >= (6, 1):
         return path.lower().endswith((".py", ".yml", ".yaml", ".json", "/", os.sep))
@@ -1656,9 +1658,8 @@ def _find_library_internal(
 
     robot_variables = None
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
-
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -1711,6 +1712,52 @@ def get_robot_library_html_doc_str(
         return output.getvalue()
 
 
+class _Logger(AbstractLogger):
+    def __init__(self) -> None:
+        super().__init__()
+        self.messages: List[Tuple[str, str, bool]] = []
+
+    def write(self, message: str, level: str, html: bool = False) -> None:
+        self.messages.append((message, level, html))
+
+
+def _import_test_library(name: str) -> Union[Any, Tuple[Any, str]]:
+    with OutputCapturer(library_import=True):
+        importer = Importer("test library", LOGGER)
+        return importer.import_class_or_module(name, return_source=True)
+
+
+def _get_test_library(
+    libcode: Any,
+    source: str,
+    name: str,
+    args: Optional[Tuple[Any, ...]] = None,
+    variables: Optional[Dict[str, Optional[Any]]] = None,
+    create_handlers: bool = True,
+    logger: Any = LOGGER,
+) -> Any:
+    if get_robot_version() < (7, 0):
+        libclass = robot.running.testlibraries._get_lib_class(libcode)
+        lib = libclass(libcode, name, args or [], source, logger, variables)
+        if create_handlers:
+            lib.create_handlers()
+    else:
+        lib = robot.running.testlibraries.TestLibrary.from_code(
+            libcode,
+            name,
+            source=Path(source),
+            args=args or [],
+            variables=variables,
+            create_keywords=create_handlers,
+            logger=logger,
+        )
+
+    return lib
+
+
+_T = TypeVar("_T")
+
+
 def get_library_doc(
     name: str,
     args: Optional[Tuple[Any, ...]] = None,
@@ -1719,45 +1766,6 @@ def get_library_doc(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> LibraryDoc:
-    class Logger(AbstractLogger):
-        def __init__(self) -> None:
-            super().__init__()
-            self.messages: List[Tuple[str, str, bool]] = []
-
-        def write(self, message: str, level: str, html: bool = False) -> None:
-            self.messages.append((message, level, html))
-
-    def import_test_library(name: str) -> Union[Any, Tuple[Any, str]]:
-        with OutputCapturer(library_import=True):
-            importer = Importer("test library", LOGGER)
-            return importer.import_class_or_module(name, return_source=True)
-
-    def get_test_library(
-        libcode: Any,
-        source: str,
-        name: str,
-        args: Optional[Tuple[Any, ...]] = None,
-        variables: Optional[Dict[str, Optional[Any]]] = None,
-        create_handlers: bool = True,
-        logger: Any = LOGGER,
-    ) -> Any:
-        if get_robot_version() < (7, 0):
-            libclass = robot.running.testlibraries._get_lib_class(libcode)
-            lib = libclass(libcode, name, args or [], source, logger, variables)
-            if create_handlers:
-                lib.create_handlers()
-        else:
-            lib = robot.running.testlibraries.TestLibrary.from_code(
-                libcode,
-                name,
-                source=Path(source),
-                args=args or [],
-                variables=variables,
-                create_keywords=create_handlers,
-                logger=logger,
-            )
-
-        return lib
 
     with _std_capture() as std_capturer:
         import_name, robot_variables = _find_library_internal(
@@ -1781,7 +1789,7 @@ def get_library_doc(
 
         source = None
         try:
-            libcode, source = import_test_library(import_name)
+            libcode, source = _import_test_library(import_name)
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -1821,13 +1829,17 @@ def get_library_doc(
 
         lib = None
         try:
-            lib = get_test_library(
+            lib = _get_test_library(
                 libcode,
                 source,
                 library_name,
                 args,
                 create_handlers=False,
-                variables=robot_variables,
+                variables=(
+                    robot_variables
+                    if robot_variables is not None
+                    else resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+                ),
             )
             if get_robot_version() < (7, 0):
                 _ = lib.get_instance()
@@ -1847,7 +1859,7 @@ def get_library_doc(
 
             if args:
                 try:
-                    lib = get_test_library(libcode, source, library_name, (), create_handlers=False)
+                    lib = _get_test_library(libcode, source, library_name, (), create_handlers=False)
                     if get_robot_version() < (7, 0):
                         _ = lib.get_instance()
                     else:
@@ -1862,6 +1874,10 @@ def get_library_doc(
         libdoc = LibraryDoc(
             name=library_name,
             source=real_source,
+            line_no=lib.lineno if lib is not None else -1,
+            version=str(lib.version) if lib is not None else "",
+            scope=str(lib.scope) if lib is not None else ROBOT_DEFAULT_SCOPE,
+            doc_format=(str(lib.doc_format) or ROBOT_DOC_FORMAT) if lib is not None else ROBOT_DOC_FORMAT,
             module_spec=(
                 module_spec
                 if module_spec is not None
@@ -1870,16 +1886,33 @@ def get_library_doc(
                 else None
             ),
             python_path=sys.path,
-            line_no=lib.lineno if lib is not None else -1,
-            doc=str(lib.doc) if lib is not None else "",
-            version=str(lib.version) if lib is not None else "",
-            scope=str(lib.scope) if lib is not None else ROBOT_DEFAULT_SCOPE,
-            doc_format=(str(lib.doc_format) or ROBOT_DOC_FORMAT) if lib is not None else ROBOT_DOC_FORMAT,
             member_name=module_spec.member_name if module_spec is not None else None,
         )
 
         if lib is not None:
             try:
+
+                def _get(handler: Callable[[], _T]) -> Optional[_T]:
+                    try:
+                        return handler()
+                    except (SystemExit, KeyboardInterrupt):
+                        raise
+                    except BaseException as e:
+                        errors.append(
+                            error_from_exception(
+                                e,
+                                source or module_spec.origin if module_spec is not None else None,
+                                (
+                                    1
+                                    if source is not None or module_spec is not None and module_spec.origin is not None
+                                    else None
+                                ),
+                            )
+                        )
+                    return None
+
+                libdoc.doc = _get(lambda: str(lib.doc) if lib is not None else "") or ""
+
                 if get_robot_version() < (7, 0):
                     libdoc.has_listener = lib.has_listener
 
@@ -1909,10 +1942,10 @@ def get_library_doc(
                     keywords=[
                         KeywordDoc(
                             name=libdoc.name,
-                            arguments=[ArgumentInfo.from_robot(a) for a in kw[0].args],
-                            doc=kw[0].doc,
-                            tags=list(kw[0].tags),
-                            source=kw[0].source,
+                            arguments=_get(lambda: [ArgumentInfo.from_robot(a) for a in kw[0].args]) or [],
+                            doc=_get(lambda: kw[0].doc) or "",
+                            tags=_get(lambda: list(kw[0].tags)) or [],
+                            source=_get(lambda: kw[0].source) or "",
                             line_no=kw[0].lineno if kw[0].lineno is not None else -1,
                             col_offset=-1,
                             end_col_offset=-1,
@@ -1923,20 +1956,23 @@ def get_library_doc(
                             longname=f"{libdoc.name}.{kw[0].name}",
                             doc_format=str(lib.doc_format) or ROBOT_DOC_FORMAT,
                             is_initializer=True,
-                            arguments_spec=ArgumentSpec.from_robot_argument_spec(
-                                kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
+                            arguments_spec=_get(
+                                lambda: ArgumentSpec.from_robot_argument_spec(
+                                    kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
+                                )
                             ),
                         )
                         for kw in init_keywords
                     ]
                 )
 
-                logger = Logger()
-                lib.logger = logger
+                logger = _Logger()
 
                 if get_robot_version() < (7, 0):
+                    lib.logger = logger
                     lib.create_handlers()
                 else:
+                    lib._logger = logger
                     lib.create_keywords()
 
                 for m in logger.messages:
@@ -1969,10 +2005,10 @@ def get_library_doc(
                     keywords=[
                         KeywordDoc(
                             name=kw[0].name,
-                            arguments=[ArgumentInfo.from_robot(a) for a in kw[0].args],
-                            doc=kw[0].doc,
-                            tags=list(kw[0].tags),
-                            source=kw[0].source,
+                            arguments=_get(lambda: [ArgumentInfo.from_robot(a) for a in kw[0].args]) or [],
+                            doc=_get(lambda: kw[0].doc) or "",
+                            tags=_get(lambda: list(kw[0].tags)) or [],
+                            source=_get(lambda: kw[0].source) or "",
                             line_no=kw[0].lineno if kw[0].lineno is not None else -1,
                             col_offset=-1,
                             end_col_offset=-1,
@@ -1987,21 +2023,26 @@ def get_library_doc(
                             is_registered_run_keyword=RUN_KW_REGISTER.is_run_keyword(libdoc.name, kw[0].name),
                             args_to_process=get_args_to_process(libdoc.name, kw[0].name),
                             deprecated=kw[0].deprecated,
-                            arguments_spec=(
-                                ArgumentSpec.from_robot_argument_spec(
-                                    kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
+                            arguments_spec=_get(
+                                lambda: (
+                                    ArgumentSpec.from_robot_argument_spec(
+                                        kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
+                                    )
+                                    if not kw[1].is_error_handler
+                                    else None
                                 )
-                                if not kw[1].is_error_handler
-                                else None
                             ),
-                            return_type=(
-                                (
-                                    str(kw[1].args.return_type)
-                                    if kw[1].args.return_type is not None and kw[1].args.return_type is not type(None)
+                            return_type=_get(
+                                lambda: (
+                                    (
+                                        str(kw[1].args.return_type)
+                                        if kw[1].args.return_type is not None
+                                        and kw[1].args.return_type is not type(None)
+                                        else None
+                                    )
+                                    if get_robot_version() >= (7, 0)
                                     else None
                                 )
-                                if get_robot_version() >= (7, 0)
-                                else None
                             ),
                         )
                         for kw in keyword_docs
@@ -2086,9 +2127,8 @@ def _find_variables_internal(
 
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
-
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -2109,12 +2149,18 @@ def resolve_args(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> Tuple[Any, ...]:
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+    # robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+    robot_variables: Any = None
 
     result = []
     for arg in args:
         if isinstance(arg, str):
-            result.append(robot_variables.replace_string(arg, ignore_errors=True))
+            if contains_variable(arg, "$@&%"):
+                if robot_variables is None:
+                    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+                result.append(robot_variables.replace_string(arg, ignore_errors=True))
+            else:
+                result.append(arg)
         else:
             result.append(arg)
 
@@ -2389,8 +2435,8 @@ def find_file(
 ) -> str:
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -2492,7 +2538,7 @@ def complete_library_import(
             if e not in DEFAULT_LIBRARIES
         ]
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)
@@ -2568,7 +2614,7 @@ def complete_resource_import(
 
     result: List[CompleteResult] = []
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)
@@ -2608,7 +2654,7 @@ def complete_variables_import(
 
     result: List[CompleteResult] = []
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)
@@ -2656,15 +2702,16 @@ def get_model_doc(
     append_model_errors: bool = True,
 ) -> LibraryDoc:
     errors: List[Error] = []
-    keyword_name_nodes: List[KeywordName] = []
-    keywords_nodes: List[Keyword] = []
-    for node in ast.walk(model):
-        if isinstance(node, Keyword):
-            keywords_nodes.append(node)
-        if isinstance(node, KeywordName):
-            keyword_name_nodes.append(node)
-
-        error = node.error if isinstance(node, HasError) else None
+    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(
@@ -2675,7 +2722,7 @@ def get_model_doc(
                 )
             )
         if append_model_errors:
-            node_errors = node.errors if isinstance(node, HasErrors) else None
+            node_errors = getattr(node, "errors", None)
             if node_errors is not None:
                 for e in node_errors:
                     errors.append(
@@ -2688,16 +2735,15 @@ def get_model_doc(
                     )
 
     def get_keyword_name_token_from_line(line: int) -> Optional[Token]:
-        for keyword_name in keyword_name_nodes:
-            if keyword_name.lineno == line:
-                return cast(Token, keyword_name.get_token(RobotToken.KEYWORD_NAME))
-
-        return None
+        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))
 
     def get_argument_definitions_from_line(
         line: int,
     ) -> List[ArgumentDefinition]:
-        keyword_node = next((k for k in keywords_nodes if k.lineno == line), None)
+        keyword_node = keywords_nodes.get(line, None)
         if keyword_node is None:
             return []