fix(vscode): some corrections in environment variable highlightning

Author: d-biehl

README.md

@@ -214,7 +214,7 @@ put this to the `settings.json`
             }
         },
         {
-            "scope": "variable.other.readwrite.robotframework",
+            "scope": "variable.name.readwrite.robotframework",
             "settings": {
                 //"fontStyle": "italic",
             }

package.json

@@ -151,7 +151,7 @@
             }
           },
           {
-            "scope": "variable.other.readwrite.robotframework",
+            "scope": "variable.name.readwrite.robotframework",
             "settings": {}
           },
           {
@@ -266,7 +266,7 @@
             "string.unquoted.embeddedArgument.robotframework"
           ],
           "variable": [
-            "variable.other.readwrite.robotframework"
+            "variable.name.readwrite.robotframework"
           ],
           "variableExpression": [
             "variable.expression.readwrite.robotframework"

packages/language_server/src/robotcode/language_server/robotframework/parts/completion.py

@@ -254,7 +254,8 @@ def get_reserved_keywords() -> List[str]:
     global __reserved_keywords
 
     if __reserved_keywords is None:
-        __reserved_keywords = ["FOR", "END", "IF", "ELSE", "ELIF", "ELSE IF"]
+        __reserved_keywords = ["FOR", "END", "IF", "ELSE", "ELSE IF"]
+
         if get_robot_version() >= (5, 0):
             __reserved_keywords += [
                 "TRY",
@@ -267,6 +268,8 @@ def get_reserved_keywords() -> List[str]:
             ]
         if get_robot_version() >= (7, 0):
             __reserved_keywords += ["VAR"]
+        else:
+            __reserved_keywords += ["ELIF"]
 
         __reserved_keywords = sorted(__reserved_keywords)
     return __reserved_keywords

packages/language_server/src/robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -348,7 +348,7 @@ def generate_sem_sub_tokens(
             if isinstance(node, (Documentation, Metadata)):
                 sem_mod = {SemanticTokenModifiers.DOCUMENTATION}
 
-            if token.type == Token.VARIABLE:
+            if token.type in [Token.VARIABLE, Token.ASSIGN]:
                 if is_variable(token.value, "$@&%"):
                     if col_offset is None:
                         col_offset = token.col_offset

packages/robot/src/robotcode/robot/diagnostics/namespace.py

@@ -99,6 +99,7 @@
     KeywordError,
     KeywordMatcher,
     LibraryDoc,
+    resolve_robot_variables,
 )
 
 EXTRACT_COMMENT_PATTERN = re.compile(r".*(?:^ *|\t+| {2,})#(?P<comment>.*)$")
@@ -184,22 +185,19 @@ def visit_Variable(self, node: Statement) -> None:  # noqa: N802
 class BlockVariableVisitor(Visitor):
     def __init__(
         self,
-        library_doc: LibraryDoc,
-        global_variables: List[VariableDefinition],
-        source: str,
+        namespace: "Namespace",
+        nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
         in_args: bool = True,
     ) -> None:
         super().__init__()
-        self.library_doc = library_doc
-        self.global_variables = global_variables
-        self.source = source
+        self.namespace = namespace
+        self.nodes = nodes
         self.position = position
         self.in_args = in_args
 
         self._results: Dict[str, VariableDefinition] = {}
         self.current_kw_doc: Optional[KeywordDoc] = None
-        self._var_statements_vars: List[VariableDefinition] = []
 
     def get(self, model: ast.AST) -> List[VariableDefinition]:
         self._results = {}
@@ -224,7 +222,7 @@ def visit_KeywordName(self, node: Statement) -> None:  # noqa: N802
         name_token = node.get_token(Token.KEYWORD_NAME)
 
         if name_token is not None and name_token.value:
-            keyword = ModelHelper.get_keyword_definition_at_token(self.library_doc, name_token)
+            keyword = ModelHelper.get_keyword_definition_at_token(self.namespace.get_library_doc(), name_token)
             self.current_kw_doc = keyword
 
             for variable_token in filter(
@@ -246,7 +244,7 @@ def visit_KeywordName(self, node: Statement) -> None:  # noqa: N802
                         col_offset=variable_token.col_offset,
                         end_line_no=variable_token.lineno,
                         end_col_offset=variable_token.end_col_offset,
-                        source=self.source,
+                        source=self.namespace.source,
                         keyword_doc=self.current_kw_doc,
                     )
 
@@ -290,7 +288,7 @@ def visit_Arguments(self, node: Statement) -> None:  # noqa: N802
                             col_offset=argument.col_offset,
                             end_line_no=argument.lineno,
                             end_col_offset=argument.end_col_offset,
-                            source=self.source,
+                            source=self.namespace.source,
                             keyword_doc=self.current_kw_doc,
                         )
                         self._results[argument.value] = arg_def
@@ -312,12 +310,48 @@ def visit_ExceptHeader(self, node: Statement) -> None:  # noqa: N802
                         col_offset=variable.col_offset,
                         end_line_no=variable.lineno,
                         end_col_offset=variable.end_col_offset,
-                        source=self.source,
+                        source=self.namespace.source,
                     )
 
             except VariableError:
                 pass
 
+    def _get_var_name(self, original: str, position: Position, require_assign: bool = True) -> Optional[str]:
+        robot_variables = resolve_robot_variables(
+            str(self.namespace.imports_manager.root_folder),
+            str(Path(self.namespace.source).parent) if self.namespace.source else ".",
+            self.namespace.imports_manager.get_resolvable_command_line_variables(),
+            variables=self.namespace.get_resolvable_variables(),
+        )
+
+        try:
+            replaced = robot_variables.replace_string(original)
+        except VariableError:
+            replaced = original
+        try:
+            name = self._resolve_var_name(replaced, robot_variables)
+        except ValueError:
+            name = original
+        match = search_variable(name, identifiers="$@&")
+        match.resolve_base(robot_variables)
+        valid = match.is_assign() if require_assign else match.is_variable()
+        if not valid:
+            return None
+        return str(match)
+
+    def _resolve_var_name(self, name: str, variables: Any) -> str:
+        if name.startswith("\\"):
+            name = name[1:]
+        if len(name) < 2 or name[0] not in "$@&":
+            raise ValueError
+        if name[1] != "{":
+            name = f"{name[0]}{{{name[1:]}}}"
+        match = search_variable(name, identifiers="$@&", ignore_errors=True)
+        match.resolve_base(variables)
+        if not match.is_assign():
+            raise ValueError
+        return str(match)
+
     def visit_KeywordCall(self, node: Statement) -> None:  # noqa: N802
         # TODO  analyze "Set Local/Global/Suite Variable"
 
@@ -341,12 +375,65 @@ def visit_KeywordCall(self, node: Statement) -> None:  # noqa: N802
                             col_offset=variable_token.col_offset,
                             end_line_no=variable_token.lineno,
                             end_col_offset=variable_token.end_col_offset,
-                            source=self.source,
+                            source=self.namespace.source,
                         )
 
             except VariableError:
                 pass
 
+        keyword_token = node.get_token(Token.KEYWORD)
+        if keyword_token is None or not keyword_token.value:
+            return
+
+        keyword = self.namespace.find_keyword(keyword_token.value, raise_keyword_error=False)
+        if keyword is None:
+            return
+
+        if keyword.libtype == "LIBRARY" and keyword.libname == "BuiltIn":
+            var_type = None
+            if keyword.name == "Set Suite Variable":
+                var_type = VariableDefinition
+            elif keyword.name == "Set Global Variable":
+                var_type = GlobalVariableDefinition
+            elif keyword.name == "Set Test Variable" or keyword.name == "Set Task Variable":
+                var_type = TestVariableDefinition
+            elif keyword.name == "Set Local Variable":
+                var_type = LocalVariableDefinition
+            else:
+                return
+            try:
+                variable = node.get_token(Token.ARGUMENT)
+                if variable is None:
+                    return
+
+                position = range_from_node(node).start
+                position.character = 0
+                var_name = self._get_var_name(variable.value, position)
+
+                if var_name is None or not is_variable(var_name):
+                    return
+
+                var = var_type(
+                    name=var_name,
+                    name_token=strip_variable_token(variable),
+                    line_no=variable.lineno,
+                    col_offset=variable.col_offset,
+                    end_line_no=variable.lineno,
+                    end_col_offset=variable.end_col_offset,
+                    source=self.namespace.source,
+                )
+
+                if var_name not in self._results or type(self._results[var_name]) != type(var):
+                    if isinstance(var, LocalVariableDefinition) or not any(
+                        l for l in self.namespace.get_global_variables() if l.matcher == var.matcher
+                    ):
+                        self._results[var_name] = var
+                    else:
+                        self._results.pop(var_name, None)
+
+            except VariableError:
+                pass
+
     def visit_InlineIfHeader(self, node: Statement) -> None:  # noqa: N802
         for assign_token in node.get_tokens(Token.ASSIGN):
             variable_token = self.get_variable_token(assign_token)
@@ -368,7 +455,7 @@ def visit_InlineIfHeader(self, node: Statement) -> None:  # noqa: N802
                             col_offset=variable_token.col_offset,
                             end_line_no=variable_token.lineno,
                             end_col_offset=variable_token.end_col_offset,
-                            source=self.source,
+                            source=self.namespace.source,
                         )
 
             except VariableError:
@@ -386,7 +473,7 @@ def visit_ForHeader(self, node: Statement) -> None:  # noqa: N802
                     col_offset=variable_token.col_offset,
                     end_line_no=variable_token.lineno,
                     end_col_offset=variable_token.end_col_offset,
-                    source=self.source,
+                    source=self.namespace.source,
                 )
 
     def visit_Var(self, node: Statement) -> None:  # noqa: N802
@@ -421,14 +508,12 @@ def visit_Var(self, node: Statement) -> None:  # noqa: N802
                 col_offset=variable.col_offset,
                 end_line_no=variable.lineno,
                 end_col_offset=variable.end_col_offset,
-                source=self.source,
+                source=self.namespace.source,
             )
 
-            self._var_statements_vars.append(var)
-
             if var_name not in self._results or type(self._results[var_name]) != type(var):
                 if isinstance(var, LocalVariableDefinition) or not any(
-                    l for l in self.global_variables if l.matcher == var.matcher
+                    l for l in self.namespace.get_global_variables() if l.matcher == var.matcher
                 ):
                     self._results[var_name] = var
                 else:
@@ -924,9 +1009,8 @@ def yield_variables(
                 (
                     (
                         BlockVariableVisitor(
-                            self.get_library_doc(),
-                            self.get_global_variables(),
-                            self.source,
+                            self,
+                            nodes,
                             position,
                             isinstance(test_or_keyword_nodes[-1], Arguments) if nodes else False,
                         ).get(test_or_keyword)

syntaxes/robotframework.tmLanguage.json

@@ -8,11 +8,11 @@
 		"variable_setting": {
 			"name": "meta.variable.assign.robotframework",
 			"contentName": "string.unquoted.argument.robotframework",
-			"begin": "^(?:([$@&%]\\{)(.*?}*)(\\})( ?=)?)",
+			"begin": "^(?:([$@&]\\{)(.*?}*)(\\})( ?=)?)",
 			"beginCaptures": {
-				"1": { "name": "unctuation.definition.variable.begin.robotframework" },
-				"2": { "name": "variable.other.readwrite.robotframework" },
-				"3": { "name": "unctuation.definition.variable.end.robotframework" },
+				"1": { "name": "punctuation.definition.variable.begin.robotframework" },
+				"2": { "name": "variable.name.readwrite.robotframework" },
+				"3": { "name": "punctuation.definition.variable.end.robotframework" },
 				"4": { "name": "keyword.operator.robotframework" }
 			},
 			"end": "^(?!\\s*\\.\\.\\.)",
@@ -42,7 +42,7 @@
 		},
 		"simple_var": {
 			"name": "meta.variables.robotframework",
-			"contentName": "variable.other.readwrite.robotframework",
+			"contentName": "variable.name.readwrite.robotframework",
 			"begin": "[$@&]\\{",
 			"end": "(\\})|(?= {2}| ?\\t| ?$)",
 			"beginCaptures": { "0": { "name": "punctuation.definition.variable.begin.robotframework" } },
@@ -51,23 +51,24 @@
 		},
 		"env_var": {
 			"name": "meta.variables.robotframework",
-			"contentName": "variable.other.readwrite.robotframework",
-			"begin": "%\\{",
+			"begin": "(%\\{)",
 			"end": "(\\})|(?= {2}| ?\\t| ?$)",
 			"beginCaptures": { "0": { "name": "punctuation.definition.envvar.begin.robotframework" } },
 			"endCaptures": { "1": { "name": "punctuation.definition.envvar.end.robotframework" } },
 			"patterns": [ { "include": "#env_key_value_pair" } ]
 		},
 		"env_key_value_pair": {
-			"match": "([^=]*)((=)(.*))?",
-			"captures": {
-				"1": { "patterns": [ { "include": "#variables" } ] },
-				"3": { "name": "keyword.operator.robotframework" },
-				"4": {
-					"name": "string.unquoted.value.robotframework",
+			"begin": "([^=\\}]*)(=)?",
+			"end": "(?=\\}| {2}| ?\\t| ?$)",
+			"contentName": "constant.character.robotframework",
+			"beginCaptures": {
+				"1": {
+					"name": "variable.name.readwrite.robotframework",
 					"patterns": [ { "include": "#variables" } ]
-				}
-			}
+				},
+				"2": { "name": "keyword.operator.robotframework" }
+			},
+			"patterns": [ { "include": "#variables" } ]
 		},
 		"comment": {
 			"name": "comment.robotframework",
@@ -123,7 +124,7 @@
 			"begin": "(?<=\\s)(?=\\s*(?:(?=[$@&])))((?:\\s)*(?:[$&@]{(?:.*?)}(?:\\[.*?\\])?(?: ?=?\\s*))*)(.*?)(?: {2,}| ?\\t ?|$)",
 			"beginCaptures": {
 				"1": {
-					"name": "variable.other.readwrite.robotframework",
+					"name": "variable.name.readwrite.robotframework",
 					"patterns": [ { "include": "#variable_assignment_from_kw" } ]
 				},
 				"2": { "name": "entity.name.function.keyword-call.robotframework" }
@@ -146,7 +147,7 @@
 			]
 		},
 		"line_continuation": {
-			"match": "^(\\s*\\.\\.\\.)(?: {2,}| ?\\t+| ?$)(?!ELSE)",
+			"match": "^(\\s*\\.\\.\\.)(?: {2,}| ?\\t+| ?$)",
 			"name": "keyword.operator.robotframework"
 		},
 		"impossible": {
@@ -877,7 +878,7 @@
 			"match": "(\\$)([[:alpha:]_]\\w*)",
 			"captures": {
 				"1": { "name": "punctuation.definition.variable.begin.robotframework" },
-				"2": { "name": "variable.other.readwrite.robotframework" }
+				"2": { "name": "variable.name.readwrite.robotframework" }
 			}
 		},
 		"ellipsis": {