robotcode-robot 0.92.0__py3-none-any.whl → 0.93.0__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "0.92.0"
+__version__ = "0.93.0"

robotcode/robot/config/loader.py

@@ -28,6 +28,7 @@ class DiscoverdBy(str, Enum):
     LOCAL_ROBOT_TOML = ".robot.toml (local file)"
     USER_DEFAULT_CONFIG_TOML = "robot.toml (user default config)"
     NOT_FOUND = "not found"
+    COMMAND_LINE = "command line"
 
 
 class ConfigType(str, Enum):
@@ -191,7 +192,13 @@ def load_robot_config_from_path(
 
 def find_project_root(
     *sources: Union[str, Path],
+    root_folder: Optional[Path] = None,
+    no_vcs: bool = False,
 ) -> Tuple[Optional[Path], DiscoverdBy]:
+
+    if root_folder:
+        return root_folder.absolute(), DiscoverdBy.COMMAND_LINE
+
     if not sources:
         sources = (str(Path.cwd().absolute()),)
 
@@ -214,11 +221,12 @@ def find_project_root(
         if (directory / PYPROJECT_TOML).is_file():
             return directory, DiscoverdBy.PYPROJECT_TOML
 
-        if (directory / ".git").exists():
-            return directory, DiscoverdBy.GIT
+        if not no_vcs:
+            if (directory / ".git").exists():
+                return directory, DiscoverdBy.GIT
 
-        if (directory / ".hg").is_dir():
-            return directory, DiscoverdBy.HG
+            if (directory / ".hg").is_dir():
+                return directory, DiscoverdBy.HG
 
     return None, DiscoverdBy.NOT_FOUND
 

robotcode/robot/config/utils.py

@@ -43,10 +43,12 @@ def get_user_config_file(
 def get_config_files(
     paths: Optional[Sequence[Union[str, Path]]] = None,
     config_files: Optional[Sequence[Path]] = None,
+    root_folder: Optional[Path] = None,
+    no_vcs: bool = False,
     *,
     verbose_callback: Optional[Callable[[str], None]] = None,
 ) -> Tuple[Sequence[Tuple[Path, ConfigType]], Optional[Path], DiscoverdBy]:
-    root_folder, discovered_by = find_project_root(*(paths or []))
+    root_folder, discovered_by = find_project_root(*(paths or []), root_folder=root_folder, no_vcs=no_vcs)
 
     if root_folder is None:
         root_folder = Path.cwd()
@@ -54,7 +56,7 @@ def get_config_files(
             verbose_callback(f"Cannot detect root folder. Use current folder '{root_folder}' as root.")
 
     if verbose_callback:
-        verbose_callback(f"Found root at:\n    {root_folder} ({discovered_by.value})")
+        verbose_callback(f"Use root at:\n    {root_folder} ({discovered_by.value})")
 
     if config_files:
         if verbose_callback:

robotcode/robot/diagnostics/entities.py

@@ -160,7 +160,7 @@ class VariableMatcher:
         return False
 
     def __hash__(self) -> int:
-        return hash(self.name)
+        return hash(self.normalized_name)
 
     def __str__(self) -> str:
         return self.name
@@ -252,7 +252,7 @@ class BuiltInVariableDefinition(VariableDefinition):
 
     @single_call
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type))
+        return hash((type(self), self.name, self.type, None, None))
 
 
 @dataclass

robotcode/robot/diagnostics/imports_manager.py

@@ -64,6 +64,7 @@ from .library_doc import (
     get_variables_doc,
     is_library_by_path,
     is_variables_by_path,
+    replace_variables_scalar,
     resolve_args,
     resolve_variable,
 )
@@ -905,7 +906,8 @@ class ImportsManager:
                 ):
                     self._logger.debug(
                         lambda: f"Ignore library {result.name or '' if result is not None else ''}"
-                        f" {result.origin or '' if result is not None else ''} for caching."
+                        f" {result.origin or '' if result is not None else ''} for caching.",
+                        context_name="import",
                     )
                     return None, import_name, ignore_arguments
 
@@ -1143,9 +1145,7 @@ class ImportsManager:
         base_dir: str,
         variables: Optional[Dict[str, Any]] = None,
     ) -> LibraryDoc:
-        meta, source, ignore_arguments = self.get_library_meta(name, base_dir, variables)
-
-        self._logger.debug(lambda: f"Load Library {source}{args!r}")
+        meta, _source, ignore_arguments = self.get_library_meta(name, base_dir, variables)
 
         if meta is not None and not meta.has_errors:
             meta_file = Path(self.lib_doc_cache_path, meta.filepath_base + ".meta.json")
@@ -1219,7 +1219,7 @@ class ImportsManager:
 
                 meta_file.write_text(as_json(meta), "utf-8")
             else:
-                self._logger.debug(lambda: f"Skip caching library {name}{args!r}")
+                self._logger.debug(lambda: f"Skip caching library {name}{args!r}", context_name="import")
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -1236,37 +1236,37 @@ class ImportsManager:
         sentinel: Any = None,
         variables: Optional[Dict[str, Any]] = None,
     ) -> LibraryDoc:
+        with self._logger.measure_time(lambda: f"loading library {name}{args!r}", context_name="import"):
+            source = self.find_library(name, base_dir, variables)
 
-        source = self.find_library(name, base_dir, variables)
-
-        resolved_args = resolve_args(
-            args,
-            str(self.root_folder),
-            base_dir,
-            self.get_resolvable_command_line_variables(),
-            variables,
-        )
-        entry_key = _LibrariesEntryKey(source, resolved_args)
-
-        with self._libaries_lock:
-            if entry_key not in self._libaries:
-                self._libaries[entry_key] = _LibrariesEntry(
-                    self,
-                    name,
-                    args,
-                    str(self.root_folder),
-                    base_dir,
-                    self._get_library_libdoc_handler(variables),
-                    ignore_reference=sentinel is None,
-                )
+            resolved_args = resolve_args(
+                args,
+                str(self.root_folder),
+                base_dir,
+                self.get_resolvable_command_line_variables(),
+                variables,
+            )
+            entry_key = _LibrariesEntryKey(source, resolved_args)
+
+            with self._libaries_lock:
+                if entry_key not in self._libaries:
+                    self._libaries[entry_key] = _LibrariesEntry(
+                        self,
+                        name,
+                        args,
+                        str(self.root_folder),
+                        base_dir,
+                        self._get_library_libdoc_handler(variables),
+                        ignore_reference=sentinel is None,
+                    )
 
-        entry = self._libaries[entry_key]
+            entry = self._libaries[entry_key]
 
-        if not entry.ignore_reference and sentinel is not None and sentinel not in entry.references:
-            weakref.finalize(sentinel, self.__remove_library_entry, entry_key, entry)
-            entry.references.add(sentinel)
+            if not entry.ignore_reference and sentinel is not None and sentinel not in entry.references:
+                weakref.finalize(sentinel, self.__remove_library_entry, entry_key, entry)
+                entry.references.add(sentinel)
 
-        return entry.get_libdoc()
+            return entry.get_libdoc()
 
     @_logger.call
     def get_libdoc_from_model(
@@ -1313,7 +1313,7 @@ class ImportsManager:
         resolve_variables: bool = True,
         resolve_command_line_vars: bool = True,
     ) -> VariablesDoc:
-        meta, source = self.get_variables_meta(
+        meta, _source = self.get_variables_meta(
             name,
             base_dir,
             variables,
@@ -1321,7 +1321,6 @@ class ImportsManager:
             resolve_command_line_vars=resolve_command_line_vars,
         )
 
-        self._logger.debug(lambda: f"Load variables {source}{args!r}")
         if meta is not None:
             meta_file = Path(
                 self.variables_doc_cache_path,
@@ -1391,7 +1390,7 @@ class ImportsManager:
                     raise RuntimeError(f"Cannot write spec file for variables '{name}' to '{spec_file}'") from e
                 meta_file.write_text(as_json(meta), "utf-8")
             else:
-                self._logger.debug(lambda: f"Skip caching variables {name}{args!r}")
+                self._logger.debug(lambda: f"Skip caching variables {name}{args!r}", context_name="import")
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -1410,39 +1409,40 @@ class ImportsManager:
         resolve_variables: bool = True,
         resolve_command_line_vars: bool = True,
     ) -> VariablesDoc:
-        source = self.find_variables(name, base_dir, variables, resolve_variables, resolve_command_line_vars)
-
-        if args:
-            resolved_args = resolve_args(
-                args,
-                str(self.root_folder),
-                base_dir,
-                self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
-                variables,
-            )
-        else:
-            resolved_args = ()
+        with self._logger.measure_time(lambda: f"getting libdoc for variables import {name}", context_name="import"):
+            source = self.find_variables(name, base_dir, variables, resolve_variables, resolve_command_line_vars)
 
-        entry_key = _VariablesEntryKey(source, resolved_args)
-
-        with self._variables_lock:
-            if entry_key not in self._variables:
-                self._variables[entry_key] = _VariablesEntry(
-                    name,
-                    resolved_args,
+            if args:
+                resolved_args = resolve_args(
+                    args,
                     str(self.root_folder),
                     base_dir,
-                    self,
-                    self._get_variables_libdoc_handler(variables, resolve_variables, resolve_command_line_vars),
+                    self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
+                    variables,
                 )
+            else:
+                resolved_args = ()
+
+            entry_key = _VariablesEntryKey(source, resolved_args)
+
+            with self._variables_lock:
+                if entry_key not in self._variables:
+                    self._variables[entry_key] = _VariablesEntry(
+                        name,
+                        resolved_args,
+                        str(self.root_folder),
+                        base_dir,
+                        self,
+                        self._get_variables_libdoc_handler(variables, resolve_variables, resolve_command_line_vars),
+                    )
 
-        entry = self._variables[entry_key]
+            entry = self._variables[entry_key]
 
-        if sentinel is not None and sentinel not in entry.references:
-            entry.references.add(sentinel)
-            weakref.finalize(sentinel, self.__remove_variables_entry, entry_key, entry)
+            if sentinel is not None and sentinel not in entry.references:
+                entry.references.add(sentinel)
+                weakref.finalize(sentinel, self.__remove_variables_entry, entry_key, entry)
 
-        return entry.get_libdoc()
+            return entry.get_libdoc()
 
     @_logger.call
     def _get_entry_for_resource_import(
@@ -1455,7 +1455,7 @@ class ImportsManager:
         source = self.find_resource(name, base_dir, variables=variables)
 
         def _get_document() -> TextDocument:
-            self._logger.debug(lambda: f"Load resource {name} from source {source}")
+            self._logger.debug(lambda: f"Load resource {name} from source {source}", context_name="import")
 
             source_path = normalized_path(Path(source))
             extension = source_path.suffix
@@ -1488,9 +1488,10 @@ class ImportsManager:
         sentinel: Any = None,
         variables: Optional[Dict[str, Any]] = None,
     ) -> Tuple["Namespace", LibraryDoc]:
-        entry = self._get_entry_for_resource_import(name, base_dir, sentinel, variables)
+        with self._logger.measure_time(lambda: f"getting namespace and libdoc for {name}", context_name="import"):
+            entry = self._get_entry_for_resource_import(name, base_dir, sentinel, variables)
 
-        return entry.get_namespace(), entry.get_libdoc()
+            return entry.get_namespace(), entry.get_libdoc()
 
     def get_namespace_for_resource_import(
         self,
@@ -1572,3 +1573,17 @@ class ImportsManager:
             self.get_resolvable_command_line_variables(),
             variables,
         )
+
+    def replace_variables_scalar(
+        self,
+        scalar: str,
+        base_dir: str = ".",
+        variables: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        return replace_variables_scalar(
+            scalar,
+            str(self.root_folder),
+            base_dir,
+            self.get_resolvable_command_line_variables(),
+            variables,
+        )

robotcode/robot/diagnostics/library_doc.py

@@ -45,12 +45,8 @@ 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.statements import Arguments, KeywordName
-from robot.running.arguments.argumentresolver import (
-    ArgumentResolver,
-    DictToKwargs,
-    NamedArgumentResolver,
-    VariableReplacer,
-)
+from robot.running.arguments.argumentresolver import ArgumentResolver, DictToKwargs, NamedArgumentResolver
+from robot.running.arguments.argumentresolver import VariableReplacer as ArgumentsVariableReplacer
 from robot.running.arguments.argumentspec import ArgInfo
 from robot.running.arguments.argumentspec import (
     ArgumentSpec as RobotArgumentSpec,
@@ -64,6 +60,7 @@ from robot.utils.robotpath import find_file as robot_find_file
 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
@@ -578,9 +575,9 @@ class ArgumentSpec:
 
         positional, named = MyNamedArgumentResolver(self.__robot_arguments).resolve(arguments, variables)
         if get_robot_version() < (7, 0):
-            positional, named = VariableReplacer(resolve_variables_until).replace(positional, named, variables)
+            positional, named = ArgumentsVariableReplacer(resolve_variables_until).replace(positional, named, variables)
         else:
-            positional, named = VariableReplacer(self.__robot_arguments, resolve_variables_until).replace(
+            positional, named = ArgumentsVariableReplacer(self.__robot_arguments, resolve_variables_until).replace(
                 positional, named, variables
             )
         positional, named = DictToKwargs(self.__robot_arguments, dict_to_kwargs).handle(positional, named)
@@ -1585,6 +1582,26 @@ def resolve_variable(
     return name.replace("\\", "\\\\")
 
 
+def replace_variables_scalar(
+    scalar: str,
+    working_dir: str = ".",
+    base_dir: str = ".",
+    command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
+    variables: Optional[Dict[str, Optional[Any]]] = None,
+) -> Any:
+
+    _update_env(working_dir)
+
+    if contains_variable(scalar, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+        if get_robot_version() >= (6, 1):
+            return VariableReplacer(robot_variables).replace_scalar(scalar.replace("\\", "\\\\"))
+
+        return VariableReplacer(robot_variables.store).replace_scalar(scalar.replace("\\", "\\\\"))
+
+    return scalar.replace("\\", "\\\\")
+
+
 @contextmanager
 def _std_capture() -> Iterator[io.StringIO]:
     old__stdout__ = sys.__stdout__

robotcode/robot/diagnostics/namespace.py

@@ -694,7 +694,14 @@ class Namespace:
         self._own_variables: Optional[List[VariableDefinition]] = None
         self._own_variables_lock = RLock(default_timeout=120, name="Namespace.own_variables")
         self._global_variables: Optional[List[VariableDefinition]] = None
+        self._global_variables_dict: Optional[Dict[VariableMatcher, VariableDefinition]] = None
         self._global_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
+        self._global_variables_dict_lock = RLock(default_timeout=120, name="Namespace.global_variables_dict")
+
+        self._global_resolvable_variables: Optional[Dict[str, Any]] = None
+        self._global_resolvable_variables_lock = RLock(
+            default_timeout=120, name="Namespace._global_resolvable_variables_lock"
+        )
 
         self._suite_variables: Optional[Dict[str, Any]] = None
         self._suite_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
@@ -993,9 +1000,12 @@ class Namespace:
         return self.imports_manager.get_command_line_variables()
 
     def _reset_global_variables(self) -> None:
-        with self._global_variables_lock, self._suite_variables_lock:
-            self._global_variables = None
-            self._suite_variables = None
+        with self._global_variables_lock, self._global_variables_dict_lock, self._suite_variables_lock:
+            with self._global_resolvable_variables_lock:
+                self._global_variables = None
+                self._global_variables_dict = None
+                self._suite_variables = None
+                self._global_resolvable_variables = None
 
     def get_global_variables(self) -> List[VariableDefinition]:
         with self._global_variables_lock:
@@ -1012,12 +1022,20 @@ class Namespace:
 
             return self._global_variables
 
+    def get_global_variables_dict(self) -> Dict[VariableMatcher, VariableDefinition]:
+        with self._global_variables_dict_lock:
+            if self._global_variables_dict is None:
+                self._global_variables_dict = {m: v for m, v in self.yield_variables()}
+
+            return self._global_variables_dict
+
     def yield_variables(
         self,
         nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
         skip_local_variables: bool = False,
+        skip_global_variables: bool = False,
     ) -> Iterator[Tuple[VariableMatcher, VariableDefinition]]:
         yielded: Dict[VariableMatcher, VariableDefinition] = {}
 
@@ -1053,7 +1071,7 @@ class Namespace:
                     else []
                 )
             ],
-            self.get_global_variables(),
+            self.get_global_variables() if not skip_global_variables else [],
         ):
             if var.matcher not in yielded:
                 if skip_commandline_variables and isinstance(var, CommandLineVariableDefinition):
@@ -1063,17 +1081,7 @@ class Namespace:
 
                 yield var.matcher, var
 
-    def get_suite_variables(
-        self,
-        nodes: Optional[List[ast.AST]] = None,
-        position: Optional[Position] = None,
-    ) -> Dict[str, Any]:
-        if nodes:
-            return {
-                v.name: v.value
-                for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
-                if v.has_value
-            }
+    def get_suite_variables(self) -> Dict[str, Any]:
         with self._suite_variables_lock:
             vars = {}
 
@@ -1093,11 +1101,21 @@ class Namespace:
         nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
     ) -> Dict[str, Any]:
-        return {
-            v.name: v.value
-            for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
-            if v.has_value
-        }
+        if nodes:
+            return {
+                v.name: v.value
+                for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
+                if v.has_value
+            }
+
+        with self._global_resolvable_variables_lock:
+            if self._global_resolvable_variables is None:
+                self._global_resolvable_variables = {
+                    v.name: v.value
+                    for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
+                    if v.has_value
+                }
+            return self._global_resolvable_variables
 
     def get_variable_matchers(
         self,
@@ -1141,9 +1159,15 @@ class Namespace:
                 position,
                 skip_commandline_variables=skip_commandline_variables,
                 skip_local_variables=skip_local_variables,
+                skip_global_variables=True,
             ):
                 if matcher == m:
                     return v
+
+            result = self.get_global_variables_dict().get(matcher, None)
+            if matcher is not None:
+                return result
+
         except InvalidVariableError:
             if not ignore_error:
                 raise
@@ -1376,12 +1400,12 @@ class Namespace:
         source: Optional[str] = None,
         parent_import: Optional[Import] = None,
         parent_source: Optional[str] = None,
-        depth: int = 0,
     ) -> Optional[Dict[str, Any]]:
 
-        current_time = time.monotonic()
-        self._logger.debug(lambda: f"{'  '*depth}start imports for {self.document if top_level else source}")
-        try:
+        with self._logger.measure_time(
+            lambda: f"loading imports for {self.source if top_level else source}",
+            context_name="import",
+        ):
             for imp in imports:
                 if variables is None:
                     variables = self.get_suite_variables()
@@ -1418,7 +1442,6 @@ class Namespace:
                                     source=entry.library_doc.source,
                                     parent_import=imp if top_level else parent_import,
                                     parent_source=parent_source if top_level else source,
-                                    depth=depth + 1,
                                 )
                             except (SystemExit, KeyboardInterrupt):
                                 raise
@@ -1568,48 +1591,40 @@ class Namespace:
                                 code=Error.LIBRARY_ALREADY_IMPORTED,
                             )
 
-        finally:
-            self._logger.debug(
-                lambda: f"{'  '*depth}end imports for "
-                f"{self.document if top_level else source} in {time.monotonic() - current_time}s"
-            )
-
         return variables
 
+    def _import_lib(self, library: str, variables: Optional[Dict[str, Any]] = None) -> Optional[LibraryEntry]:
+        try:
+            return self._get_library_entry(
+                library,
+                (),
+                None,
+                str(Path(self.source).parent),
+                is_default_library=True,
+                variables=variables,
+            )
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except BaseException as e:
+            self.append_diagnostics(
+                range=Range.zero(),
+                message=f"Can't import default library '{library}': {str(e) or type(e).__name__}",
+                severity=DiagnosticSeverity.ERROR,
+                source="Robot",
+                code=type(e).__qualname__,
+            )
+            return None
+
     def _import_default_libraries(self, variables: Optional[Dict[str, Any]] = None) -> None:
-        def _import_lib(library: str, variables: Optional[Dict[str, Any]] = None) -> Optional[LibraryEntry]:
-            try:
-                return self._get_library_entry(
-                    library,
-                    (),
-                    None,
-                    str(Path(self.source).parent),
-                    is_default_library=True,
-                    variables=variables,
-                )
-            except (SystemExit, KeyboardInterrupt):
-                raise
-            except BaseException as e:
-                self.append_diagnostics(
-                    range=Range.zero(),
-                    message=f"Can't import default library '{library}': {str(e) or type(e).__name__}",
-                    severity=DiagnosticSeverity.ERROR,
-                    source="Robot",
-                    code=type(e).__qualname__,
-                )
-                return None
 
-        self._logger.debug(lambda: f"start import default libraries for document {self.document}")
-        try:
+        with self._logger.measure_time(lambda: f"importing default libraries for {self.source}", context_name="import"):
             if variables is None:
                 variables = self.get_suite_variables()
 
             for library in DEFAULT_LIBRARIES:
-                e = _import_lib(library, variables)
+                e = self._import_lib(library, variables)
                 if e is not None:
                     self._libraries[e.alias or e.name or e.import_name] = e
-        finally:
-            self._logger.debug(lambda: f"end import default libraries for document {self.document}")
 
     @_logger.call
     def _get_library_entry(
@@ -1820,8 +1835,6 @@ class Namespace:
 
     @_logger.call(condition=lambda self: not self._analyzed)
     def analyze(self) -> None:
-        import time
-
         from .namespace_analyzer import NamespaceAnalyzer
 
         with self._analyze_lock:
@@ -1830,53 +1843,43 @@ class Namespace:
 
                 self.ensure_initialized()
 
-                self._logger.debug(lambda: f"start analyze {self.document}")
-                start_time = time.monotonic()
-
-                try:
-                    result = NamespaceAnalyzer(self.model, self, self.create_finder()).run()
+                with self._logger.measure_time(lambda: f"analyzing document {self.source}", context_name="analyze"):
+                    try:
+                        result = NamespaceAnalyzer(self.model, self, self.create_finder()).run()
 
-                    self._diagnostics += result.diagnostics
-                    self._keyword_references = result.keyword_references
-                    self._variable_references = result.variable_references
-                    self._local_variable_assignments = result.local_variable_assignments
-                    self._namespace_references = result.namespace_references
+                        self._diagnostics += result.diagnostics
+                        self._keyword_references = result.keyword_references
+                        self._variable_references = result.variable_references
+                        self._local_variable_assignments = result.local_variable_assignments
+                        self._namespace_references = result.namespace_references
 
-                    lib_doc = self.get_library_doc()
+                        lib_doc = self.get_library_doc()
 
-                    if lib_doc.errors is not None:
-                        for err in lib_doc.errors:
-                            self.append_diagnostics(
-                                range=Range(
-                                    start=Position(
-                                        line=((err.line_no - 1) if err.line_no is not None else 0),
-                                        character=0,
-                                    ),
-                                    end=Position(
-                                        line=((err.line_no - 1) if err.line_no is not None else 0),
-                                        character=0,
+                        if lib_doc.errors is not None:
+                            for err in lib_doc.errors:
+                                self.append_diagnostics(
+                                    range=Range(
+                                        start=Position(
+                                            line=((err.line_no - 1) if err.line_no is not None else 0),
+                                            character=0,
+                                        ),
+                                        end=Position(
+                                            line=((err.line_no - 1) if err.line_no is not None else 0),
+                                            character=0,
+                                        ),
                                     ),
-                                ),
-                                message=err.message,
-                                severity=DiagnosticSeverity.ERROR,
-                                source=DIAGNOSTICS_SOURCE_NAME,
-                                code=err.type_name,
-                            )
-                # TODO: implement CancelationToken
-                except CancelledError:
-                    canceled = True
-                    self._logger.debug("analyzing canceled")
-                    raise
-                finally:
-                    self._analyzed = not canceled
-
-                    self._logger.debug(
-                        lambda: (
-                            f"end analyzed {self.document} succeed in {time.monotonic() - start_time}s"
-                            if self._analyzed
-                            else f"end analyzed {self.document} failed in {time.monotonic() - start_time}s"
-                        )
-                    )
+                                    message=err.message,
+                                    severity=DiagnosticSeverity.ERROR,
+                                    source=DIAGNOSTICS_SOURCE_NAME,
+                                    code=err.type_name,
+                                )
+                    # TODO: implement CancelationToken
+                    except CancelledError:
+                        canceled = True
+                        self._logger.debug("analyzing canceled")
+                        raise
+                    finally:
+                        self._analyzed = not canceled
 
                 self.has_analysed(self)
 

robotcode/robot/utils/ast.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import ast
 import itertools
-from typing import Any, Iterator, List, Optional, Sequence, Set, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union
+
+from typing_extensions import TypeGuard
 
 from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
@@ -17,17 +19,42 @@ if get_robot_version() < (7, 0):
 else:
     from robot.variables.search import VariableMatches as VariableIterator
 
+_cached_isinstance_cache: Dict[Tuple[type, Tuple[type, ...]], bool] = {}
+
+_T = TypeVar("_T")
+
+
+def cached_isinstance(obj: Any, *expected_types: Type[_T]) -> TypeGuard[Union[_T]]:
+    try:
+        t = type(obj)
+        if (t, expected_types) in _cached_isinstance_cache:
+            return _cached_isinstance_cache[(t, expected_types)]
+
+        _cached_isinstance_cache[(t, expected_types)] = result = isinstance(obj, expected_types)
+
+        return result
+
+    except TypeError:
+        return False
+
+
+# def cached_isinstance(obj: Any, *expected_types: type) -> bool:
+#     try:
+#         return isinstance(obj, expected_types)
+#     except TypeError:
+#         return False
+
 
 def iter_nodes(node: ast.AST, descendants: bool = True) -> Iterator[ast.AST]:
     for _field, value in ast.iter_fields(node):
-        if isinstance(value, list):
+        if cached_isinstance(value, list):
             for item in value:
-                if isinstance(item, ast.AST):
+                if cached_isinstance(item, ast.AST):
                     yield item
                     if descendants:
                         yield from iter_nodes(item)
 
-        elif isinstance(value, ast.AST):
+        elif cached_isinstance(value, ast.AST):
             yield value
             if descendants:
                 yield from iter_nodes(value)
@@ -53,7 +80,7 @@ class FirstAndLastRealStatementFinder(Visitor):
         return finder.first_statement, finder.last_statement
 
     def visit_Statement(self, statement: ast.AST) -> None:  # noqa: N802
-        if not isinstance(statement, EmptyLine):
+        if not cached_isinstance(statement, EmptyLine):
             if self.first_statement is None:
                 self.first_statement = statement
 
@@ -63,7 +90,7 @@ class FirstAndLastRealStatementFinder(Visitor):
 def _get_non_data_range_from_node(
     node: ast.AST, only_start: bool = False, allow_comments: bool = False
 ) -> Optional[Range]:
-    if isinstance(node, Statement) and node.tokens:
+    if cached_isinstance(node, Statement) and node.tokens:
         start_token = next(
             (
                 v
@@ -115,7 +142,7 @@ def range_from_node(
     allow_comments: bool = False,
 ) -> Range:
     if skip_non_data:
-        if isinstance(node, Statement) and node.tokens:
+        if cached_isinstance(node, Statement) and node.tokens:
             result = _get_non_data_range_from_node(node, only_start, allow_comments)
             if result is not None:
                 return result

{robotcode_robot-0.92.0.dist-info → robotcode_robot-0.93.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-robot
-Version: 0.92.0
+Version: 0.93.0
 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.92.0
+Requires-Dist: robotcode-core==0.93.0
 Requires-Dist: robotframework>=4.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-0.92.0.dist-info → robotcode_robot-0.93.0.dist-info}/RECORD

@@ -1,30 +1,30 @@
 robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=4oQqdZ-jW338RGQfLxI7hoQNb8tTR6y4hzWoJRPdI3o,23
+robotcode/robot/__version__.py,sha256=W-KEJT0wpRrG8XJ2aDG4NSyzaUucgZR9y6mwfCTlku4,23
 robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
 robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/config/loader.py,sha256=5PQTWDn1vYFN0VmLVhEYdu12Foq1AwRtDFvjU44QQvw,7878
+robotcode/robot/config/loader.py,sha256=bNJwr_XdCoUzpG2ag0BH33PIfiCwn0GMxn7q_Sw3zOk,8103
 robotcode/robot/config/model.py,sha256=sgr6-4_E06g-yIXW41Z-NtIXZ_7JMmR5WvUD7kTUqu4,89106
-robotcode/robot/config/utils.py,sha256=c_WZg39DJgM6kXcAH_h-v68qhf1eStJ0TslTawaJoZw,2827
+robotcode/robot/config/utils.py,sha256=xY-LH31BidWzonpvSrle-4HvKrp02I7IRqU2JwlL4Ls,2931
 robotcode/robot/diagnostics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=3dDsu8-ET6weIvv7Sk3IQaPYFNxnXUs8Y7gpGTjfOBs,9796
 robotcode/robot/diagnostics/document_cache_helper.py,sha256=MlOPXC3mUVjNB2rHn5UJK7NnUPa8S4mE3qojILOi_Mk,23756
-robotcode/robot/diagnostics/entities.py,sha256=AtrqPAS3XUC-8VpFmqMXfMKjQHmfxXZlyGWWFaEBpQA,10979
+robotcode/robot/diagnostics/entities.py,sha256=dWZFSrAuW9wzW9AEDSr-stseexLbJIYfdScfAbBj4FY,11002
 robotcode/robot/diagnostics/errors.py,sha256=HCE0h0_ui1tx-6pJHs0r4s09ZHmArYwKUo-_lBl9K-4,1600
-robotcode/robot/diagnostics/imports_manager.py,sha256=qE__lm0Hsj3R0gUauXRmbWJPYihNjk3O-c5hcICGQjc,56251
-robotcode/robot/diagnostics/library_doc.py,sha256=CHgyC9GMRQFP3fGTxWa139rIcGIk8Ys6Q_ZIDSgse7k,97324
+robotcode/robot/diagnostics/imports_manager.py,sha256=GvcIEqghVjtliTWUwQo4N-xier00CGnEh_eO7l05cJg,57187
+robotcode/robot/diagnostics/library_doc.py,sha256=7m29COvY_YlK_n9dj57q0c7sFRThoR_X4bgdZapWwaY,98160
 robotcode/robot/diagnostics/model_helper.py,sha256=_5ixKKMrb-nY-uvV8_WjJ1rlNlz7gT7kHM5NYi_hjVg,30232
-robotcode/robot/diagnostics/namespace.py,sha256=jCUb5GmMDA6KTr2BnwHD_0Mp_gTg1XGskUvRYPL7XQ0,89543
+robotcode/robot/diagnostics/namespace.py,sha256=lH5RReu-fW0g8CZBh9LKWHItCZh14D-XFvFdYUvBoDg,90151
 robotcode/robot/diagnostics/namespace_analyzer.py,sha256=3eC1xEBm_foCnqoHk8Cj6O11UXOHcHxWnfuKP8M5KIQ,51369
 robotcode/robot/diagnostics/workspace_config.py,sha256=3SoewUj_LZB1Ki5hXM8oxQpJr6vyiog66SUw-ibODSA,2478
 robotcode/robot/utils/__init__.py,sha256=OjNPMn_XSnfaMCyKd8Kmq6vlRt6mIGlzW4qiiD3ykUg,447
-robotcode/robot/utils/ast.py,sha256=ynxvXv1SHkAcF07m76ey9_zaGCYXhlPOnny7km-XWSQ,10479
+robotcode/robot/utils/ast.py,sha256=_ob36KHFY776n9dhljn0xAWVoUDb7pV86fPW40vIirY,11266
 robotcode/robot/utils/markdownformatter.py,sha256=0XZZ5wDU2yfzIuShjG7h79PgzMaQJ501WH4YRFcG1VM,11615
 robotcode/robot/utils/match.py,sha256=ofyfXgrvVddl7a064Dk5Kiqp3a-n_6gTIgqDbL3E80Q,632
 robotcode/robot/utils/robot_path.py,sha256=qKBh1cEnReBBLKkWu4gB9EzM-scAwE4xJc1m6v2LRN0,1786
 robotcode/robot/utils/stubs.py,sha256=6-DMI_CQVJHDgG13t-zINKGCRb_Q7MQPm0_AkfhAEvE,748
 robotcode/robot/utils/variables.py,sha256=fEl8S37lb_mD4hn2MZRAlkiuLGBjAOeZVK0r2o2CfPw,742
 robotcode/robot/utils/visitor.py,sha256=uYLqEhGPmzWKWI3SSrmCaYMwtKvNShvbiPZ4b3FavX8,3241
-robotcode_robot-0.92.0.dist-info/METADATA,sha256=H_aQghUcVbx_6vUwIw0DTqVSUhN1ewvzGjinWv-MEX0,2240
-robotcode_robot-0.92.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-robotcode_robot-0.92.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-robotcode_robot-0.92.0.dist-info/RECORD,,
+robotcode_robot-0.93.0.dist-info/METADATA,sha256=64V1dXSzlmT6KArsIP0YqCm79s_oPXVm3MXBlenwx2E,2240
+robotcode_robot-0.93.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+robotcode_robot-0.93.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+robotcode_robot-0.93.0.dist-info/RECORD,,