robotcode-robot 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "1.2.0"
+__version__ = "1.3.0"

robotcode/robot/config/model.py

@@ -2371,11 +2371,11 @@ class RobotConfig(RobotExtendBaseProfile):
 
             Examples:
             ```toml
-            default_profiles = "default"
+            default-profiles = "default"
             ```
 
             ```toml
-            default_profiles = ["default", "Firefox"]
+            default-profiles = ["default", "Firefox"]
             ```
             """
     )

robotcode/robot/diagnostics/entities.py

@@ -17,10 +17,9 @@ from typing_extensions import Concatenate, ParamSpec
 
 from robot.parsing.lexer.tokens import Token
 from robotcode.core.lsp.types import Position, Range
-from robotcode.robot.utils.match import normalize
 
 from ..utils.ast import range_from_token
-from ..utils.variables import search_variable
+from ..utils.variables import VariableMatcher, search_variable
 
 if TYPE_CHECKING:
     from robotcode.robot.diagnostics.library_doc import KeywordDoc, LibraryDoc
@@ -164,48 +163,6 @@ class VariablesImport(Import):
         return hash((type(self), self.name, self.args))
 
 
-class InvalidVariableError(Exception):
-    pass
-
-
-class VariableMatcher:
-    def __init__(self, name: str) -> None:
-        self.name = name
-
-        match = search_variable(name, "$@&%", ignore_errors=True)
-
-        if match.base is None:
-            raise InvalidVariableError(f"Invalid variable '{name}'")
-
-        self.base = match.base
-
-        self.normalized_name = normalize(self.base)
-
-    def __eq__(self, o: object) -> bool:
-        if type(o) is VariableMatcher:
-            return o.normalized_name == self.normalized_name
-
-        if type(o) is str:
-            match = search_variable(o, "$@&%", ignore_errors=True)
-            base = match.base
-            if base is None:
-                return False
-
-            normalized = normalize(base)
-            return self.normalized_name == normalized
-
-        return False
-
-    def __hash__(self) -> int:
-        return hash(self.normalized_name)
-
-    def __str__(self) -> str:
-        return self.name
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}(name={self.name!r})"
-
-
 class VariableDefinitionType(Enum):
     VARIABLE = "suite variable"
     LOCAL_VARIABLE = "local variable"
@@ -230,10 +187,17 @@ class VariableDefinition(SourceEntity):
 
     value: Any = field(default=None, compare=False)
     value_is_native: bool = field(default=False, compare=False)
+    value_type: Optional[str] = field(default=None, compare=False)
 
     @functools.cached_property
     def matcher(self) -> VariableMatcher:
-        return VariableMatcher(self.name)
+        return search_variable(self.name)
+
+    @functools.cached_property
+    def convertable_name(self) -> str:
+        m = self.matcher
+        value_type = f": {self.value_type}" if self.value_type else ""
+        return f"{m.identifier}{{{m.base.strip()}{value_type}}}"
 
     @single_call
     def __hash__(self) -> int:
@@ -311,6 +275,15 @@ class ArgumentDefinition(LocalVariableDefinition):
         return hash((type(self), self.name, self.type, self.range, self.source))
 
 
+@dataclass
+class EmbeddedArgumentDefinition(ArgumentDefinition):
+    pattern: Optional[str] = field(default=None, compare=False)
+
+    @single_call
+    def __hash__(self) -> int:
+        return hash((type(self), self.name, self.type, self.range, self.source))
+
+
 @dataclass
 class LibraryArgumentDefinition(ArgumentDefinition):
     @single_call

robotcode/robot/diagnostics/errors.py

@@ -43,3 +43,4 @@ class Error:
     VARIABLE_OVERRIDDEN = "VariableOverridden"
     MODEL_ERROR = "ModelError"
     TOKEN_ERROR = "TokenError"
+    ASSIGN_MARK_ALLOWED_ONLY_ON_LAST_VAR = "AssignmentMarkAllowedOnlyOnLastVariable"

robotcode/robot/diagnostics/imports_manager.py

@@ -1527,11 +1527,11 @@ class ImportsManager:
         variables: Optional[Dict[str, Any]] = None,
     ) -> _ResourcesEntry:
         source = self.find_resource(name, base_dir, variables=variables)
+        source_path = normalized_path(Path(source))
 
         def _get_document() -> TextDocument:
-            self._logger.debug(lambda: f"Load resource {name} from source {source}", context_name="import")
+            self._logger.debug(lambda: f"Load resource {name} from source {source_path}", context_name="import")
 
-            source_path = normalized_path(Path(source))
             extension = source_path.suffix
             if extension.lower() not in RESOURCE_EXTENSIONS:
                 raise ImportError(
@@ -1541,7 +1541,7 @@ class ImportsManager:
 
             return self.documents_manager.get_or_open_document(source_path)
 
-        entry_key = _ResourcesEntryKey(source)
+        entry_key = _ResourcesEntryKey(str(source_path))
 
         with self._resources_lock:
             if entry_key not in self._resources:

robotcode/robot/diagnostics/keyword_finder.py

@@ -87,9 +87,25 @@ class KeywordFinder:
             try:
                 result = self._find_keyword(name, handle_bdd_style)
                 if result is None:
+                    error_message = "No keyword with found."
+
+                    if name and name.strip(": ").upper() == "FOR":
+                        error_message = (
+                            f"Support for the old FOR loop syntax has been removed. "
+                            f"Replace '{name}' with 'FOR', end the loop with 'END', and "
+                            f"remove escaping backslashes."
+                        )
+                    elif name and name == "\\":
+                        error_message = (
+                            "No keyword with name '\\' found. If it is used inside a for "
+                            "loop, remove escaping backslashes and end the loop with 'END'."
+                        )
+                    else:
+                        error_message = f"No keyword with name '{name}' found."
+
                     self.diagnostics.append(
                         DiagnosticsEntry(
-                            f"No keyword with name '{name}' found.",
+                            error_message,
                             DiagnosticSeverity.ERROR,
                             Error.KEYWORD_NOT_FOUND,
                         )
@@ -306,17 +322,32 @@ class KeywordFinder:
                 return True
         return False
 
-    def _is_better_match(
-        self,
-        candidate: Tuple[Optional[LibraryEntry], KeywordDoc],
-        other: Tuple[Optional[LibraryEntry], KeywordDoc],
-    ) -> bool:
-        return (
-            other[1].matcher.embedded_arguments is not None
-            and candidate[1].matcher.embedded_arguments is not None
-            and other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
-            and candidate[1].matcher.embedded_arguments.match(other[1].name) is None
-        )
+    if get_robot_version() >= (7, 3):
+
+        def _is_better_match(
+            self,
+            candidate: Tuple[Optional[LibraryEntry], KeywordDoc],
+            other: Tuple[Optional[LibraryEntry], KeywordDoc],
+        ) -> bool:
+            return (
+                other[1].matcher.embedded_arguments is not None
+                and candidate[1].matcher.embedded_arguments is not None
+                and other[1].matcher.embedded_arguments.matches(candidate[1].name)
+                and not candidate[1].matcher.embedded_arguments.matches(other[1].name)
+            )
+    else:
+
+        def _is_better_match(
+            self,
+            candidate: Tuple[Optional[LibraryEntry], KeywordDoc],
+            other: Tuple[Optional[LibraryEntry], KeywordDoc],
+        ) -> bool:
+            return (
+                other[1].matcher.embedded_arguments is not None
+                and candidate[1].matcher.embedded_arguments is not None
+                and other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
+                and candidate[1].matcher.embedded_arguments.match(other[1].name) is None
+            )
 
     @functools.cached_property
     def _resource_imports(self) -> List[ResourceEntry]:

robotcode/robot/diagnostics/library_doc.py

@@ -67,7 +67,7 @@ from robotcode.core.utils.path import normalized_path
 from ..utils import get_robot_version
 from ..utils.ast import (
     cached_isinstance,
-    get_variable_token,
+    get_first_variable_token,
     range_from_token,
     strip_variable_token,
 )
@@ -199,7 +199,7 @@ def convert_from_rest(text: str) -> str:
 
 
 if get_robot_version() >= (6, 0):
-    # monkey patch robot framework
+    # monkey patch robot framework for performance reasons
     _old_from_name = EmbeddedArguments.from_name
 
     @functools.lru_cache(maxsize=8192)
@@ -214,8 +214,14 @@ if get_robot_version() >= (6, 0):
         except (VariableError, DataError):
             return ()
 
-    def _match_embedded(embedded_arguments: EmbeddedArguments, name: str) -> bool:
-        return embedded_arguments.match(name) is not None
+    if get_robot_version() >= (7, 3):
+
+        def _match_embedded(embedded_arguments: EmbeddedArguments, name: str) -> bool:
+            return bool(embedded_arguments.matches(name))
+    else:
+
+        def _match_embedded(embedded_arguments: EmbeddedArguments, name: str) -> bool:
+            return embedded_arguments.match(name) is not None
 
 else:
 
@@ -2779,7 +2785,7 @@ def _get_argument_definitions_from_line(
 
     for argument_token in (cast(RobotToken, e) for e in arguments):
         try:
-            argument = get_variable_token(argument_token)
+            argument = get_first_variable_token(argument_token)
 
             if argument is not None and argument.value != "@{}":
                 if argument.value not in args:

robotcode/robot/diagnostics/model_helper.py

@@ -253,7 +253,7 @@ class ModelHelper:
 
         return lib_entry, kw_namespace
 
-    match_extended = re.compile(
+    MATCH_EXTENDED = re.compile(
         r"""
     (.+?)          # base name (group 1)
     ([^\s\w].+)    # extended part (group 2)
@@ -500,9 +500,9 @@ class ModelHelper:
                     and sub_token.value[1:2] == "{"
                     and sub_token.value[-1:] == "}"
                 ):
-                    match = cls.match_extended.match(name[2:-1])
-                    if match is not None:
-                        base_name, _ = match.groups()
+                    extended_match = cls.MATCH_EXTENDED.match(name[2:-1])
+                    if extended_match is not None:
+                        base_name, _ = extended_match.groups()
                         name = f"{name[0]}{{{base_name.strip()}}}"
                         var = namespace.find_variable(
                             name,