robotcode-robot 2.8.0.dev548__tar.gz → 2.8.0.dev631__tar.gz

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev631}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotcode-robot
-Version: 2.8.0-dev.548
+Version: 2.8.0-dev.631
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -27,7 +27,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: platformdirs>=4.3
-Requires-Dist: robotcode-core==2.8.0-dev.548
+Requires-Dist: robotcode-core==2.8.0-dev.631
 Requires-Dist: robotframework>=5.0.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev631}/pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
   "robotframework>=5.0.0",
   "tomli>=1.1.0; python_version < '3.11'",
   "platformdirs>=4.3",
-  "robotcode-core==2.8.0-dev.548",
+  "robotcode-core==2.8.0-dev.631",
 ]
 dynamic = ["version"]
 

robotcode_robot-2.8.0.dev631/src/robotcode/robot/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.8.0-dev.631"

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev631}/src/robotcode/robot/diagnostics/library_doc.py

@@ -1930,13 +1930,16 @@ class LibraryDoc:
     def _get_title_markdown(self, header_level: int) -> str:
         result = f"#{'#' * header_level} {(self.type.capitalize()) if self.type else 'Unknown'} *{self.name}*\n\n"
 
-        if self.version or self.scope:
+        # resource and suite files show GLOBAL, as in Libdoc; variable files have no scope in Robot Framework
+        scope = self.scope if self.type != "VARIABLES" else ""
+
+        if self.version or scope:
             result += "|  |  |\n| :--- | :--- |\n"
 
             if self.version:
                 result += f"| **Library Version:** | {self.version} |\n"
-            if self.scope:
-                result += f"| **Library Scope:** | {self.scope} |\n"
+            if scope:
+                result += f"| **Library Scope:** | {scope} |\n"
 
             result += "\n\n"
 

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev631}/src/robotcode/robot/diagnostics/namespace_analyzer.py

@@ -1458,7 +1458,10 @@ class NamespaceAnalyzer(Visitor):
                     ignore_errors=True,
                 )
 
-                if not matcher.is_assign(allow_assign_mark=True, allow_nested=True) or matcher.name is None:
+                if (
+                    not matcher.is_assign(allow_assign_mark=True, allow_nested=True, allow_items=True)
+                    or matcher.name is None
+                ):
                     return
 
                 if RF_VERSION >= (7, 0) and contains_variable(matcher.base, "$@&%"):
@@ -1496,6 +1499,19 @@ class NamespaceAnalyzer(Visitor):
                 stripped_name_token = strip_variable_token(assign_token, matcher=matcher, parse_type=True)
 
                 if matcher.items:
+                    # Robot Framework resolves the variables in the index; the search without types keeps a type
+                    # in the base, so the index starts after it
+                    raw = search_variable(matcher.string, ignore_errors=True)
+                    items_start = raw.start + len(raw.identifier) + len(raw.base) + 2
+                    items_token = Token(
+                        Token.ARGUMENT,
+                        matcher.string[items_start : raw.end],
+                        assign_token.lineno,
+                        assign_token.col_offset + items_start,
+                    )
+                    for var_token, var in self._iter_variables_from_token(items_token):
+                        self._handle_find_variable_result(var_token, var)
+
                     existing_var = self._find_variable(name)
                     if existing_var is None:
                         self._handle_find_variable_result(
@@ -1611,18 +1627,21 @@ class NamespaceAnalyzer(Visitor):
                 if not matcher.is_scalar_assign():
                     return
 
-                if (
-                    next(
-                        (
-                            k
-                            for k, v in self._variables.items()
-                            if k == matcher
-                            and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
-                        ),
-                        None,
+                existing_var = next(
+                    (
+                        v
+                        for k, v in self._variables.items()
+                        if k == matcher
+                        and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
+                    ),
+                    None,
+                )
+                if existing_var is not None:
+                    # EXCEPT AS sets the existing variable again, like a FOR variable of that name
+                    self._variable_references[existing_var].add(
+                        Location(self._document_uri, range_from_token(strip_variable_token(variable_token)))
                     )
-                    is None
-                ):
+                else:
                     var_def = LocalVariableDefinition(
                         name=variable_token.value,
                         name_token=strip_variable_token(variable_token),

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev631}/src/robotcode/robot/diagnostics/semantic_analyzer/analyzer.py

@@ -405,6 +405,8 @@ class SemanticAnalyzer(Visitor):
             )
             self._logger.exception(e)
 
+        self._mark_argument_uses()
+
         # Build indexes
         self._semantic_model.build_index()
 
@@ -423,6 +425,38 @@ class SemanticAnalyzer(Visitor):
             semantic_model=self._semantic_model,
         )
 
+    def _mark_argument_uses(self) -> None:
+        """Mark every variable token whose name the analysis resolved to an argument from `[Arguments]`, the same
+        resolution Find References and Rename use; embedded arguments stay unmarked."""
+        starts = {
+            (location.range.start.line, location.range.start.character)
+            for var, locations in self._variable_references.items()
+            if isinstance(var, ArgumentDefinition) and not isinstance(var, EmbeddedArgumentDefinition)
+            for location in locations
+        }
+        if starts:
+            for stmt in self._semantic_model.statements:
+                self._mark_argument_uses_in_statement(stmt, starts)
+
+    def _mark_argument_uses_in_statement(self, stmt: SemanticStatement, starts: Set[Tuple[int, int]]) -> None:
+        for token in stmt.tokens:
+            self._mark_argument_uses_in_token(token, starts)
+        # the inner calls of a Run Keyword variant have tokens of their own
+        if isinstance(stmt, RunKeywordCallStatement):
+            for inner in stmt.inner_calls:
+                self._mark_argument_uses_in_statement(inner, starts)
+
+    def _mark_argument_uses_in_token(self, token: SemanticToken, starts: Set[Tuple[int, int]]) -> None:
+        for sub in token.sub_tokens or ():
+            self._mark_argument_uses_in_token(sub, starts)
+            # a reference covers the name of the variable, its base
+            if (
+                token.kind is TokenKind.VARIABLE
+                and sub.kind is TokenKind.VARIABLE_BASE
+                and (sub.range.start.line, sub.range.start.character) in starts
+            ):
+                token.modifiers = (token.modifiers or frozenset()) | {TokenModifier.ARGUMENT}
+
     # --- Semantic Model helpers ---
 
     # Statement kinds that act as the block-header for control-flow blocks.
@@ -3176,7 +3210,10 @@ class SemanticAnalyzer(Visitor):
                     ignore_errors=True,
                 )
 
-                if not matcher.is_assign(allow_assign_mark=True, allow_nested=True) or matcher.name is None:
+                if (
+                    not matcher.is_assign(allow_assign_mark=True, allow_nested=True, allow_items=True)
+                    or matcher.name is None
+                ):
                     return
 
                 if RF_VERSION >= (7, 0) and contains_variable(matcher.base, "$@&%"):
@@ -3220,6 +3257,19 @@ class SemanticAnalyzer(Visitor):
                 stripped_name_token = strip_variable_token(assign_token, matcher=matcher, parse_type=True)
 
                 if matcher.items:
+                    # Robot Framework resolves the variables in the index; the search without types keeps a type
+                    # in the base, so the index starts after it
+                    raw = search_variable(matcher.string, ignore_errors=True)
+                    items_start = raw.start + len(raw.identifier) + len(raw.base) + 2
+                    items_token = Token(
+                        Token.ARGUMENT,
+                        matcher.string[items_start : raw.end],
+                        assign_token.lineno,
+                        assign_token.col_offset + items_start,
+                    )
+                    for var_token, var in self._iter_variables_from_token(items_token):
+                        self._handle_find_variable_result(var_token, var)
+
                     existing_var = self._find_variable(name)
                     if existing_var is None:
                         self._handle_find_variable_result(
@@ -3468,18 +3518,21 @@ class SemanticAnalyzer(Visitor):
                 if not matcher.is_scalar_assign():
                     return
 
-                if (
-                    next(
-                        (
-                            k
-                            for k, v in self._variables.items()
-                            if k == matcher
-                            and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
-                        ),
-                        None,
+                existing_var = next(
+                    (
+                        v
+                        for k, v in self._variables.items()
+                        if k == matcher
+                        and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
+                    ),
+                    None,
+                )
+                if existing_var is not None:
+                    # EXCEPT AS sets the existing variable again, like a FOR variable of that name
+                    self._variable_references[existing_var].add(
+                        Location(self._document_uri, range_from_token(strip_variable_token(variable_token)))
                     )
-                    is None
-                ):
+                else:
                     var_def = LocalVariableDefinition(
                         name=variable_token.value,
                         name_token=strip_variable_token(variable_token),

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev631}/src/robotcode/robot/diagnostics/semantic_analyzer/enums.py

@@ -194,6 +194,7 @@ class TokenModifier(Enum):
     EMBEDDED = "embedded"
     DECLARATION = "declaration"
     DOCUMENTATION = "documentation"
+    ARGUMENT = "argument"  # a variable that names an argument from the keyword's [Arguments], not an embedded one
 
 
 class ForFlavor(Enum):

robotcode_robot-2.8.0.dev548/src/robotcode/robot/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.8.0-dev.548"