robotcode-robot 0.95.0__py3-none-any.whl → 0.95.2__py3-none-any.whl

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,
-    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]
@@ -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:
@@ -239,59 +252,50 @@ 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
+        )
 
     @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
 
-    @property
-    def embedded_arguments(self) -> Any:
-        if self._embedded_arguments is None:
-            if self._can_have_embedded:
-                self._embedded_arguments = _get_embedded_arguments(self.name)
-            else:
-                self._embedded_arguments = ()
-
-        return self._embedded_arguments
-
-    if get_robot_version() >= (6, 0):
-
-        def __match_embedded(self, name: str) -> bool:
-            return self.embedded_arguments.match(name) is not None
-
-    else:
-
-        def __match_embedded(self, name: str) -> bool:
-            return 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
 
-            if not self.embedded_arguments:
+            if self.embedded_arguments is not None:
                 return self.normalized_name == o.normalized_name
 
             o = o.name
 
-        if not cached_isinstance(o, str):
+        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:
@@ -618,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
@@ -667,13 +670,15 @@ class KeywordDoc(SourceEntity):
     def __str__(self) -> str:
         return f"{self.name}({', '.join(str(arg) for arg in self.arguments)})"
 
-    @property
+    @functools.cached_property
+    def is_embedded(self) -> bool:
+        return self.matcher.embedded_arguments is not None
+
+    @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
 
@@ -685,31 +690,31 @@ 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)
 
         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
 
-    @property
+    @functools.cached_property
     def range(self) -> Range:
         if self.name_token is not None:
             return range_from_token(self.name_token)
@@ -820,7 +825,7 @@ class KeywordDoc(SourceEntity):
 
         return result
 
-    @property
+    @functools.cached_property
     def signature(self) -> str:
         return (
             f'({self.type}) "{self.name}": ('
@@ -893,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,
@@ -919,19 +923,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:
-        items = [(k, v) for k, v in self._matchers.items() if k == key]
+        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 = ""
@@ -946,14 +944,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:
-        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)
@@ -983,7 +981,7 @@ class KeywordStore:
         return list(self.iter_all(key))
 
     def iter_all(self, key: str) -> Iterable[KeywordDoc]:
-        yield from (v for k, v in self._matchers.items() if k == key)
+        return (v for v in self.keywords if v.matcher.match_string(key))
 
 
 @dataclass
@@ -1296,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))
@@ -2030,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,
@@ -2710,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: 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
-        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 = node.errors if isinstance(node, HasErrors) else 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
-                        )
-                    )
+if get_robot_version() < (7, 0):
 
-    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))
+    class _MyUserLibrary(UserLibrary):
+        current_kw: Any = None
 
-        return None
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            self.errors: List[Error] = []
+            super().__init__(*args, **kwargs)
 
-    def get_argument_definitions_from_line(
-        line: int,
-    ) -> List[ArgumentDefinition]:
-        keyword_node = next((k for k in keywords_nodes if k.lineno == line), None)
-        if keyword_node is None:
-            return []
+        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)
 
-        arguments_node = next(
-            (n for n in ast.walk(keyword_node) if isinstance(n, Arguments)),
-            None,
-        )
-        if arguments_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,
+                )
+                self.errors.append(err)
 
-        args: List[str] = []
-        arguments = arguments_node.get_tokens(RobotToken.ARGUMENT)
-        argument_definitions = []
+                handler = UserErrorHandler(e, kw.name, self.name)
+                handler.source = kw.source
+                handler.lineno = kw.lineno
 
-        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,
-                        )
-                        argument_definitions.append(arg_def)
+                handler.errors = [err]
 
-            except VariableError:
-                pass
+            return handler
 
-        return argument_definitions
 
-    res = ResourceFile(source=source)
+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))
 
-    with LOGGER.cache_only:
-        ResourceBuilder(res).visit(model)
 
-    if get_robot_version() < (7, 0):
+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 []
 
-        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 _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)
+    args: List[str] = []
+    arguments = arguments_node.get_tokens(RobotToken.ARGUMENT)
+    argument_definitions = []
 
-            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,
+    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
 
@@ -2847,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,
@@ -2875,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,
@@ -2883,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
@@ -2892,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/diagnostics/model_helper.py

@@ -665,12 +665,12 @@ class ModelHelper:
 
     @classmethod
     def get_keyword_definition_at_token(cls, library_doc: LibraryDoc, token: Token) -> Optional[KeywordDoc]:
-        return cls.get_keyword_definition_at_line(library_doc, token.value, token.lineno)
+        return cls.get_keyword_definition_at_line(library_doc, token.lineno)
 
     @classmethod
-    def get_keyword_definition_at_line(cls, library_doc: LibraryDoc, value: str, line: int) -> Optional[KeywordDoc]:
+    def get_keyword_definition_at_line(cls, library_doc: LibraryDoc, line: int) -> Optional[KeywordDoc]:
         return next(
-            (k for k in library_doc.keywords.iter_all(value) if k.line_no == line),
+            (k for k in library_doc.keywords.keywords if k.line_no == line),
             None,
         )
 

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(