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

robotcode/robot/diagnostics/diagnostics_modifier.py

@@ -2,7 +2,8 @@ import functools
 import re as re
 from ast import AST
 from collections import defaultdict
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from enum import Enum
 from typing import Dict, List, Optional, Set, Union
 
 from robot.parsing.lexer.tokens import Token
@@ -12,15 +13,32 @@ from robotcode.core.lsp.types import Diagnostic, DiagnosticSeverity
 
 from ..utils.visitor import Visitor
 
-ACTIONS = ["ignore", "error", "warn", "information", "hint", "reset"]
+ACTIONS = ["ignore", "error", "warn", "warning", "info", "information", "hint", "reset"]
 
 ROBOTCODE_ACTION_AND_CODES_PATTERN = re.compile(rf"(?P<action>{'|'.join(ACTIONS)})(\[(?P<codes>[^\]]*?)\])?")
 
 
+class ModifierAction(Enum):
+    IGNORE = "ignore"
+    ERROR = "error"
+    WARNING = "warning"
+    INFORMATION = "information"
+    HINT = "hint"
+    RESET = "reset"
+
+    @classmethod
+    def from_str(cls, value: str) -> "ModifierAction":
+        if value == "warn":
+            value = "warning"
+        elif value == "info":
+            value = "information"
+        return cls(value)
+
+
 @dataclass
 class RulesAndCodes:
     codes: Dict[Union[str, int], Set[int]]
-    actions: Dict[int, Dict[Union[str, int], str]]
+    actions: Dict[int, Dict[Union[str, int], ModifierAction]]
 
 
 _translation_table = str.maketrans("", "", "_- ")
@@ -28,7 +46,7 @@ _translation_table = str.maketrans("", "", "_- ")
 ROBOTCODE_MARKER = "robotcode:"
 
 
-class DisablersVisitor(Visitor):
+class ModifiersVisitor(Visitor):
 
     def __init__(self) -> None:
         super().__init__()
@@ -65,8 +83,8 @@ class DisablersVisitor(Visitor):
         self._handle_statement_comments(node)
         self.generic_visit(node)
 
-    def _parse_robotcode_disabler(self, comment: str) -> Dict[str, List[str]]:
-        result: Dict[str, List[str]] = {}
+    def _parse_robotcode_disabler(self, comment: str) -> Dict[ModifierAction, List[str]]:
+        result: Dict[ModifierAction, List[str]] = {}
 
         comment = comment.strip()
         m = ROBOTCODE_ACTION_AND_CODES_PATTERN.match(comment)
@@ -74,7 +92,8 @@ class DisablersVisitor(Visitor):
             return result
 
         for m in ROBOTCODE_ACTION_AND_CODES_PATTERN.finditer(comment):
-            action = m.group("action")
+            action_str = m.group("action")
+            action = ModifierAction.from_str(action_str)
             messages = m.group("codes")
             result[action] = (
                 [m.strip().translate(_translation_table).lower() for m in messages.split(",")]
@@ -153,19 +172,36 @@ class DisablersVisitor(Visitor):
                             self.rules_and_codes.actions[i][code] = action
 
 
+@dataclass
+class DiagnosticModifiersConfig:
+    ignore: List[str] = field(default_factory=list)
+    error: List[str] = field(default_factory=list)
+    warning: List[str] = field(default_factory=list)
+    information: List[str] = field(default_factory=list)
+    hint: List[str] = field(default_factory=list)
+
+
 class DiagnosticsModifier:
-    def __init__(self, model: AST) -> None:
+    def __init__(self, model: AST, config: Optional[DiagnosticModifiersConfig] = None) -> None:
+        self.config = config or DiagnosticModifiersConfig()
+
+        self.config.ignore = [i.translate(_translation_table).lower() for i in self.config.ignore]
+        self.config.error = [i.translate(_translation_table).lower() for i in self.config.error]
+        self.config.warning = [i.translate(_translation_table).lower() for i in self.config.warning]
+        self.config.information = [i.translate(_translation_table).lower() for i in self.config.information]
+        self.config.hint = [i.translate(_translation_table).lower() for i in self.config.hint]
+
         self.model = model
 
     @functools.cached_property
     def rules_and_codes(self) -> RulesAndCodes:
-        visitor = DisablersVisitor()
+        visitor = ModifiersVisitor()
         visitor.visit(self.model)
         return visitor.rules_and_codes
 
     def modify_diagnostic(self, diagnostic: Diagnostic) -> Optional[Diagnostic]:
         if diagnostic.code is not None:
-            code = (
+            code = orig_code = (
                 str(diagnostic.code).translate(_translation_table).lower()
                 if diagnostic.code is not None
                 else "unknowncode"
@@ -177,24 +213,51 @@ class DiagnosticsModifier:
                 code = "*"
                 lines = self.rules_and_codes.codes.get(code)
 
+            modified = False
             if lines is not None and diagnostic.range.start.line in lines:
                 actions = self.rules_and_codes.actions.get(diagnostic.range.start.line)
                 if actions is not None:
                     action = actions.get(code)
                     if action is not None:
-                        if action == "ignore":
+                        if action == ModifierAction.IGNORE:
                             return None
-                        if action == "reset":
-                            pass  # do nothing
-                        elif action == "error":
+                        if action == ModifierAction.RESET:
+                            pass
+                        elif action == ModifierAction.ERROR:
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.ERROR
-                        elif action == "warn":
+                        elif action == ModifierAction.WARNING:
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.WARNING
-                        elif action == "information":
+                        elif action == ModifierAction.INFORMATION:
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.INFORMATION
-                        elif action == "hint":
+                        elif action == ModifierAction.HINT:
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.HINT
 
+            if not modified:
+                if orig_code in self.config.ignore:
+                    return None
+                if orig_code in self.config.error:
+                    diagnostic.severity = DiagnosticSeverity.ERROR
+                elif orig_code in self.config.warning:
+                    diagnostic.severity = DiagnosticSeverity.WARNING
+                elif orig_code in self.config.information:
+                    diagnostic.severity = DiagnosticSeverity.INFORMATION
+                elif orig_code in self.config.hint:
+                    diagnostic.severity = DiagnosticSeverity.HINT
+                elif "*" in self.config.hint:
+                    diagnostic.severity = DiagnosticSeverity.HINT
+                elif "*" in self.config.information:
+                    diagnostic.severity = DiagnosticSeverity.INFORMATION
+                elif "*" in self.config.warning:
+                    diagnostic.severity = DiagnosticSeverity.WARNING
+                elif "*" in self.config.error:
+                    diagnostic.severity = DiagnosticSeverity.ERROR
+                elif "*" in self.config.ignore:
+                    return None
+
         return diagnostic
 
     def modify_diagnostics(self, diagnostics: List[Diagnostic]) -> List[Diagnostic]:

robotcode/robot/diagnostics/document_cache_helper.py

@@ -26,7 +26,7 @@ from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.core.workspace import Workspace, WorkspaceFolder
-from robotcode.robot.diagnostics.diagnostics_modifier import DiagnosticsModifier
+from robotcode.robot.diagnostics.diagnostics_modifier import DiagnosticModifiersConfig, DiagnosticsModifier
 
 from ..config.model import RobotBaseProfile
 from ..utils import get_robot_version
@@ -34,7 +34,13 @@ from ..utils.stubs import Languages
 from .imports_manager import ImportsManager
 from .library_doc import LibraryDoc
 from .namespace import DocumentType, Namespace
-from .workspace_config import AnalysisRobotConfig, CacheConfig, RobotConfig
+from .workspace_config import (
+    AnalysisDiagnosticModifiersConfig,
+    AnalysisRobotConfig,
+    CacheConfig,
+    RobotConfig,
+    WorkspaceAnalysisConfig,
+)
 
 
 class UnknownFileTypeError(Exception):
@@ -54,6 +60,7 @@ class DocumentsCacheHelper:
         documents_manager: DocumentsManager,
         file_watcher_manager: FileWatcherManagerBase,
         robot_profile: Optional[RobotBaseProfile],
+        analysis_config: Optional[WorkspaceAnalysisConfig],
     ) -> None:
         self.INITIALIZED_NAMESPACE = _CacheEntry()
 
@@ -62,6 +69,7 @@ class DocumentsCacheHelper:
         self.file_watcher_manager = file_watcher_manager
 
         self.robot_profile = robot_profile or RobotBaseProfile()
+        self.analysis_config = analysis_config or WorkspaceAnalysisConfig()
 
         self._imports_managers_lock = threading.RLock()
         self._imports_managers: weakref.WeakKeyDictionary[WorkspaceFolder, ImportsManager] = weakref.WeakKeyDictionary()
@@ -514,10 +522,10 @@ class DocumentsCacheHelper:
             variables,
             variable_files,
             environment,
-            cache_config.ignored_libraries,
-            cache_config.ignored_variables,
-            cache_config.ignore_arguments_for_library,
-            analysis_config.global_library_search_order,
+            self.analysis_config.cache.ignored_libraries + cache_config.ignored_libraries,
+            self.analysis_config.cache.ignored_variables + cache_config.ignored_variables,
+            self.analysis_config.cache.ignore_arguments_for_library + cache_config.ignore_arguments_for_library,
+            self.analysis_config.robot.global_library_search_order + analysis_config.global_library_search_order,
             cache_base_path,
         )
 
@@ -583,4 +591,14 @@ class DocumentsCacheHelper:
         return document.get_cache(self.__get_diagnostic_modifier)
 
     def __get_diagnostic_modifier(self, document: TextDocument) -> DiagnosticsModifier:
-        return DiagnosticsModifier(self.get_model(document, False))
+        modifiers_config = self.workspace.get_configuration(AnalysisDiagnosticModifiersConfig, document.uri)
+        return DiagnosticsModifier(
+            self.get_model(document, False),
+            DiagnosticModifiersConfig(
+                ignore=self.analysis_config.modifiers.ignore + modifiers_config.ignore,
+                error=self.analysis_config.modifiers.error + modifiers_config.error,
+                warning=self.analysis_config.modifiers.warning + modifiers_config.warning,
+                information=self.analysis_config.modifiers.information + modifiers_config.information,
+                hint=self.analysis_config.modifiers.hint + modifiers_config.hint,
+            ),
+        )

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__