fix(analyse): correct handling of keyword arguments in all other keyword settings, regardless of the order of the settings.

closes #240

Author: d-biehl

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

@@ -258,6 +258,7 @@ def iter_expression_variables_from_token(
         nodes: Optional[List[ast.AST]],
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
+        skip_local_variables: bool = False,
         return_not_found: bool = False,
     ) -> Iterator[Tuple[Token, VariableDefinition]]:
         variable_started = False
@@ -270,6 +271,7 @@ def iter_expression_variables_from_token(
                             nodes,
                             position,
                             skip_commandline_variables=skip_commandline_variables,
+                            skip_local_variables=skip_local_variables,
                             ignore_error=True,
                         )
                         sub_token = Token(
@@ -376,6 +378,7 @@ def iter_variables_from_token(
         nodes: Optional[List[ast.AST]],
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
+        skip_local_variables: bool = False,
         return_not_found: bool = False,
     ) -> Iterator[Tuple[Token, VariableDefinition]]:
         def is_number(name: str) -> bool:
@@ -405,6 +408,7 @@ def iter_token(
                             nodes,
                             position,
                             skip_commandline_variables=skip_commandline_variables,
+                            skip_local_variables=skip_local_variables,
                             return_not_found=return_not_found,
                         ):
                             yield v
@@ -461,6 +465,7 @@ def iter_token(
                     nodes,
                     position,
                     skip_commandline_variables=skip_commandline_variables,
+                    skip_local_variables=skip_local_variables,
                     ignore_error=True,
                 )
                 if var is not None:
@@ -485,6 +490,7 @@ def iter_token(
                             nodes,
                             position,
                             skip_commandline_variables=skip_commandline_variables,
+                            skip_local_variables=skip_local_variables,
                             ignore_error=True,
                         )
                         sub_sub_token = Token(

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

@@ -26,13 +26,8 @@
 from robot.errors import VariableError
 from robot.libraries import STDLIBS
 from robot.parsing.lexer.tokens import Token
-from robot.parsing.model.blocks import (
-    Keyword,
-    SettingSection,
-    TestCase,
-    VariableSection,
-)
-from robot.parsing.model.statements import Arguments, Statement
+from robot.parsing.model.blocks import Keyword, SettingSection, TestCase, VariableSection
+from robot.parsing.model.statements import Arguments, Fixture, Statement, Timeout
 from robot.parsing.model.statements import LibraryImport as RobotLibraryImport
 from robot.parsing.model.statements import ResourceImport as RobotResourceImport
 from robot.parsing.model.statements import (
@@ -182,7 +177,7 @@ def visit_Variable(self, node: Statement) -> None:  # noqa: N802
             )
 
 
-class BlockVariableVisitor(Visitor):
+class VariableVisitorBase(Visitor):
     def __init__(
         self,
         namespace: "Namespace",
@@ -198,7 +193,79 @@ def __init__(
 
         self._results: Dict[str, VariableDefinition] = {}
         self.current_kw_doc: Optional[KeywordDoc] = None
+        self.current_kw: Optional[Keyword] = None
+
+    def get_variable_token(self, token: Token) -> Optional[Token]:
+        return next(
+            (
+                v
+                for v in itertools.dropwhile(
+                    lambda t: t.type in Token.NON_DATA_TOKENS,
+                    tokenize_variables(token, ignore_errors=True, extra_types={Token.VARIABLE}),
+                )
+                if v.type == Token.VARIABLE
+            ),
+            None,
+        )
+
+
+class ArgumentVisitor(VariableVisitorBase):
+    def __init__(
+        self,
+        namespace: "Namespace",
+        nodes: Optional[List[ast.AST]],
+        position: Optional[Position],
+        in_args: bool,
+        current_kw_doc: Optional[KeywordDoc],
+    ) -> None:
+        super().__init__(namespace, nodes, position, in_args)
+
+        self.current_kw_doc: Optional[KeywordDoc] = current_kw_doc
+
+    def get(self, model: ast.AST) -> Dict[str, VariableDefinition]:
+        self._results = {}
+
+        self.visit(model)
+
+        return self._results
+
+    def visit_Arguments(self, node: Statement) -> None:  # noqa: N802
+        args: List[str] = []
+
+        arguments = node.get_tokens(Token.ARGUMENT)
+
+        for argument_token in arguments:
+            try:
+                argument = self.get_variable_token(argument_token)
+
+                if argument is not None and argument.value != "@{}":
+                    if (
+                        self.in_args
+                        and self.position is not None
+                        and self.position in range_from_token(argument_token)
+                        and self.position > range_from_token(argument).end
+                    ):
+                        break
+
+                    if argument.value not in args:
+                        args.append(argument.value)
+                        arg_def = ArgumentDefinition(
+                            name=argument.value,
+                            name_token=strip_variable_token(argument),
+                            line_no=argument.lineno,
+                            col_offset=argument.col_offset,
+                            end_line_no=argument.lineno,
+                            end_col_offset=argument.end_col_offset,
+                            source=self.namespace.source,
+                            keyword_doc=self.current_kw_doc,
+                        )
+                        self._results[argument.value] = arg_def
+
+            except VariableError:
+                pass
 
+
+class OnlyArgumentsVisitor(VariableVisitorBase):
     def get(self, model: ast.AST) -> List[VariableDefinition]:
         self._results = {}
 
@@ -211,9 +278,11 @@ def visit(self, node: ast.AST) -> None:
             super().visit(node)
 
     def visit_Keyword(self, node: ast.AST) -> None:  # noqa: N802
+        self.current_kw = cast(Keyword, node)
         try:
             self.generic_visit(node)
         finally:
+            self.current_kw = None
             self.current_kw_doc = None
 
     def visit_KeywordName(self, node: Statement) -> None:  # noqa: N802
@@ -248,53 +317,15 @@ def visit_KeywordName(self, node: Statement) -> None:  # noqa: N802
                         keyword_doc=self.current_kw_doc,
                     )
 
-    def get_variable_token(self, token: Token) -> Optional[Token]:
-        return next(
-            (
-                v
-                for v in itertools.dropwhile(
-                    lambda t: t.type in Token.NON_DATA_TOKENS,
-                    tokenize_variables(token, ignore_errors=True, extra_types={Token.VARIABLE}),
-                )
-                if v.type == Token.VARIABLE
-            ),
-            None,
-        )
-
-    def visit_Arguments(self, node: Statement) -> None:  # noqa: N802
-        args: List[str] = []
+            if self.current_kw is not None:
+                args = ArgumentVisitor(
+                    self.namespace, self.nodes, self.position, self.in_args, self.current_kw_doc
+                ).get(self.current_kw)
+                if args:
+                    self._results.update(args)
 
-        arguments = node.get_tokens(Token.ARGUMENT)
 
-        for argument_token in arguments:
-            try:
-                argument = self.get_variable_token(argument_token)
-
-                if argument is not None and argument.value != "@{}":
-                    if (
-                        self.in_args
-                        and self.position is not None
-                        and self.position in range_from_token(argument_token)
-                        and self.position > range_from_token(argument).end
-                    ):
-                        break
-
-                    if argument.value not in args:
-                        args.append(argument.value)
-                        arg_def = ArgumentDefinition(
-                            name=argument.value,
-                            name_token=strip_variable_token(argument),
-                            line_no=argument.lineno,
-                            col_offset=argument.col_offset,
-                            end_line_no=argument.lineno,
-                            end_col_offset=argument.end_col_offset,
-                            source=self.namespace.source,
-                            keyword_doc=self.current_kw_doc,
-                        )
-                        self._results[argument.value] = arg_def
-
-            except VariableError:
-                pass
+class BlockVariableVisitor(OnlyArgumentsVisitor):
 
     def visit_ExceptHeader(self, node: Statement) -> None:  # noqa: N802
         variables = node.get_tokens(Token.VARIABLE)[:1]
@@ -990,10 +1021,12 @@ def yield_variables(
         nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
+        skip_local_variables: bool = False,
     ) -> Iterator[Tuple[VariableMatcher, VariableDefinition]]:
         yielded: Dict[VariableMatcher, VariableDefinition] = {}
 
         test_or_keyword = None
+        test_or_keyword_nodes = None
 
         if nodes:
             test_or_keyword_nodes = list(
@@ -1004,18 +1037,23 @@ def yield_variables(
             )
             test_or_keyword = test_or_keyword_nodes[0] if test_or_keyword_nodes else None
 
+        in_args = isinstance(test_or_keyword_nodes[-1], Arguments) if test_or_keyword_nodes else False
+        only_args = (
+            isinstance(test_or_keyword_nodes[-1], (Arguments, Fixture, Timeout)) if test_or_keyword_nodes else False
+        )
+
         for var in chain(
             *[
                 (
                     (
-                        BlockVariableVisitor(
+                        (OnlyArgumentsVisitor if only_args else BlockVariableVisitor)(
                             self,
                             nodes,
                             position,
-                            isinstance(test_or_keyword_nodes[-1], Arguments) if nodes else False,
+                            in_args,
                         ).get(test_or_keyword)
                     )
-                    if test_or_keyword is not None
+                    if test_or_keyword is not None and not skip_local_variables
                     else []
                 )
             ],
@@ -1081,6 +1119,7 @@ def find_variable(
         nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
+        skip_local_variables: bool = False,
         ignore_error: bool = False,
     ) -> Optional[VariableDefinition]:
         self.ensure_initialized()
@@ -1105,6 +1144,7 @@ def find_variable(
                 nodes,
                 position,
                 skip_commandline_variables=skip_commandline_variables,
+                skip_local_variables=skip_local_variables,
             ):
                 if matcher == m:
                     return v

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

@@ -12,12 +12,14 @@
 from robot.parsing.model.blocks import Keyword, TestCase
 from robot.parsing.model.statements import (
     Arguments,
+    DefaultTags,
     DocumentationOrMetadata,
     Fixture,
     KeywordCall,
     LibraryImport,
     ResourceImport,
     Statement,
+    Tags,
     Template,
     TemplateArguments,
     TestCaseName,
@@ -70,9 +72,35 @@
 
 if get_robot_version() < (7, 0):
     from robot.variables.search import VariableIterator
+
+    VARIABLE_NOT_FOUND_HINT_TYPES: Tuple[Any, ...] = (
+        DocumentationOrMetadata,
+        TestCaseName,
+        Tags,
+        robot.parsing.model.statements.ForceTags,
+        DefaultTags,
+    )
+
+    IN_SETTING_TYPES: Tuple[Any, ...] = (
+        DocumentationOrMetadata,
+        Tags,
+        robot.parsing.model.statements.ForceTags,
+        DefaultTags,
+        Template,
+    )
 else:
     from robot.variables.search import VariableMatches
 
+    VARIABLE_NOT_FOUND_HINT_TYPES = (
+        DocumentationOrMetadata,
+        TestCaseName,
+        Tags,
+        robot.parsing.model.statements.TestTags,
+        DefaultTags,
+    )
+
+    IN_SETTING_TYPES = (DocumentationOrMetadata, Tags, robot.parsing.model.statements.TestTags, DefaultTags, Template)
+
 
 @dataclass
 class AnalyzerResult:
@@ -266,10 +294,10 @@ def visit(self, node: ast.AST) -> None:
 
         self.node_stack.append(node)
         try:
+            in_setting = isinstance(node, IN_SETTING_TYPES)
+
             severity = (
-                DiagnosticSeverity.HINT
-                if isinstance(node, (DocumentationOrMetadata, TestCaseName))
-                else DiagnosticSeverity.ERROR
+                DiagnosticSeverity.HINT if isinstance(node, VARIABLE_NOT_FOUND_HINT_TYPES) else DiagnosticSeverity.ERROR
             )
 
             if isinstance(node, KeywordCall) and node.keyword:
@@ -295,6 +323,7 @@ def visit(self, node: ast.AST) -> None:
                             self.node_stack,
                             range_from_token(token).start,
                             skip_commandline_variables=False,
+                            skip_local_variables=in_setting,
                             return_not_found=True,
                         ):
                             if isinstance(var, VariableNotFoundDefinition):
@@ -380,6 +409,7 @@ def visit(self, node: ast.AST) -> None:
                     self.node_stack,
                     range_from_token(token).start,
                     skip_commandline_variables=False,
+                    skip_local_variables=in_setting,
                     return_not_found=True,
                 ):
                     if isinstance(var, VariableNotFoundDefinition):