complete assign keywords and correct goto for variables

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -149,12 +149,12 @@ def __hash__(self) -> int:
     def range(self) -> Range:
         return Range(
             start=Position(
-                line=self.name_token.lineno - 1 if self.name_token is not None else self.line_no - 1,
-                character=self.name_token.col_offset if self.name_token is not None else self.col_offset,
+                line=self.line_no - 1,
+                character=self.col_offset,
             ),
             end=Position(
-                line=self.name_token.lineno - 1 if self.name_token is not None else self.end_line_no - 1,
-                character=self.name_token.end_col_offset if self.name_token is not None else self.end_col_offset,
+                line=self.end_line_no - 1,
+                character=self.end_col_offset,
             ),
         )
 
@@ -212,39 +212,77 @@ async def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
             )
 
 
-class ArgumentsVisitor(AsyncVisitor):
+class BlockVariableVisitor(AsyncVisitor):
     async def get(self, source: str, model: ast.AST) -> List[VariableDefinition]:
         self._results: List[VariableDefinition] = []
         self.source = source
         await self.visit(model)
         return self._results
 
-    async def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.model.blocks import VariableSection
-
-        if isinstance(node, VariableSection):
-            await self.generic_visit(node)
-
     async def visit_Arguments(self, node: ast.AST) -> None:  # noqa: N802
+        from robot.errors import VariableError
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import Arguments
         from robot.variables.search import is_variable
 
         n = cast(Arguments, node)
         arguments = n.get_tokens(RobotToken.ARGUMENT)
         for argument in (cast(RobotToken, e) for e in arguments):
-            if is_variable(argument.value):
+            try:
+                if is_variable(argument.value):
+                    self._results.append(
+                        ArgumentDefinition(
+                            name=argument.value,
+                            name_token=argument,
+                            line_no=node.lineno,
+                            col_offset=node.col_offset,
+                            end_line_no=node.end_lineno
+                            if node.end_lineno is not None
+                            else argument.lineno
+                            if argument.lineno is not None
+                            else -1,
+                            end_col_offset=node.end_col_offset
+                            if node.end_col_offset is not None
+                            else argument.end_col_offset
+                            if argument.end_col_offset is not None
+                            else -1,
+                            source=self.source,
+                        )
+                    )
+            except VariableError:
+                pass
+
+    async def visit_KeywordCall(self, node: ast.AST) -> None:  # noqa: N802
+        from robot.errors import VariableError
+        from robot.parsing.lexer.tokens import Token as RobotToken
+        from robot.parsing.model.statements import KeywordCall
+        from robot.variables.search import contains_variable
+
+        try:
+            n = cast(KeywordCall, node)
+            assign_token = n.get_token(RobotToken.ASSIGN)
+            if assign_token is not None and assign_token.value and contains_variable(assign_token.value):
                 self._results.append(
-                    ArgumentDefinition(
-                        name=argument.value,
-                        name_token=argument,
-                        line_no=argument.lineno,
-                        col_offset=argument.col_offset,
-                        end_line_no=argument.lineno if argument.lineno is not None else -1,
-                        end_col_offset=argument.end_col_offset if argument.end_col_offset is not None else -1,
+                    VariableDefinition(
+                        name=assign_token.value,
+                        name_token=assign_token,
+                        line_no=node.lineno,
+                        col_offset=node.col_offset,
+                        end_line_no=node.end_lineno
+                        if node.end_lineno is not None
+                        else assign_token.lineno
+                        if assign_token.lineno is not None
+                        else -1,
+                        end_col_offset=node.end_col_offset
+                        if node.end_col_offset is not None
+                        else assign_token.end_col_offset
+                        if assign_token.end_col_offset is not None
+                        else -1,
                         source=self.source,
                     )
                 )
+        except VariableError:
+            pass
 
 
 class ImportVisitor(AsyncVisitor):
@@ -851,14 +889,18 @@ def get_builtin_variables(cls) -> List[BuiltInVariableDefinition]:
         return cls._builtin_variables
 
     async def get_variables(self, nodes: Optional[List[ast.AST]] = None) -> Dict[VariableMatcher, VariableDefinition]:
-        from robot.parsing.model.blocks import Keyword
+        from robot.parsing.model.blocks import Keyword, TestCase
 
         await self._ensure_initialized()
 
         result: Dict[VariableMatcher, VariableDefinition] = {}
 
         async for var in async_chain(
-            *[await ArgumentsVisitor().get(self.source, n) for n in nodes or [] if isinstance(n, Keyword)],
+            *[
+                await BlockVariableVisitor().get(self.source, n)
+                for n in nodes or []
+                if isinstance(n, (Keyword, TestCase))
+            ],
             (e for e in await self.get_own_variables()),
             *(e.variables for e in self._resources.values()),
             (e for e in self.get_builtin_variables()),

robotcode/language_server/robotframework/parts/completion.py

@@ -308,7 +308,7 @@ async def create_environment_variables_completion_items(self, range: Optional[Ra
     }
 
     async def create_variables_completion_items(
-        self, range: Optional[Range], nodes: Optional[List[ast.AST]] = None
+        self, range: Range, nodes: List[ast.AST], position: Position
     ) -> List[CompletionItem]:
         if self.document is None:
             return []
@@ -327,12 +327,11 @@ async def create_variables_completion_items(
                 text_edit=TextEdit(
                     range=range,
                     new_text=s.name[2:-1],
-                )
-                if range is not None
-                else None,
+                ),
+                filter_text=s.name[2:-1] if range is not None else None,
             )
             for s in (await namespace.get_variables(nodes)).values()
-            if s.name is not None
+            if s.name is not None and (s.name_token is None or not position.is_in_range(range_from_token(s.name_token)))
         ]
 
     async def create_settings_completion_items(self, range: Optional[Range]) -> List[CompletionItem]:
@@ -624,7 +623,7 @@ async def complete_default(
                 )
                 if token_at_position.value[open_brace_index - 1] == "%":
                     return await self.create_environment_variables_completion_items(range)
-                return await self.create_variables_completion_items(range, nodes_at_position)
+                return await self.create_variables_completion_items(range, nodes_at_position, position)
 
         return None
 

robotcode/language_server/robotframework/parts/goto.py

@@ -114,7 +114,9 @@ async def _definition_default(
                                     origin_selection_range=range_from_token_or_node(node, sub_token),
                                     target_uri=str(Uri.from_path(variable.source)),
                                     target_range=variable.range(),
-                                    target_selection_range=variable.range(),
+                                    target_selection_range=range_from_token(variable.name_token)
+                                    if variable.name_token
+                                    else variable.range(),
                                 )
                             ]
             except BaseException: