implement analysing parameters of keyword calls

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -18,8 +18,9 @@
 from ..utils.ast import (
     Token,
     is_not_variable_token,
+    range_from_node,
+    range_from_node_or_token,
     range_from_token,
-    range_from_token_or_node,
 )
 from ..utils.async_ast import AsyncVisitor
 from .library_doc import KeywordDoc, is_embedded_keyword
@@ -45,7 +46,7 @@ async def visit(self, node: ast.AST) -> None:
     async def _analyze_keyword_call(
         self,
         keyword: Optional[str],
-        value: ast.AST,
+        node: ast.AST,
         keyword_token: Token,
         argument_tokens: List[Token],
         analyse_run_keywords: bool = True,
@@ -60,7 +61,7 @@ async def _analyze_keyword_call(
             for e in self.finder.diagnostics:
                 self._results.append(
                     Diagnostic(
-                        range=range_from_token_or_node(value, keyword_token),
+                        range=range_from_node_or_token(node, keyword_token),
                         message=e.message,
                         severity=e.severity,
                         source=DIAGNOSTICS_SOURCE_NAME,
@@ -72,7 +73,7 @@ async def _analyze_keyword_call(
                 if result.errors:
                     self._results.append(
                         Diagnostic(
-                            range=range_from_token_or_node(value, keyword_token),
+                            range=range_from_node_or_token(node, keyword_token),
                             message="Keyword definition contains errors.",
                             severity=DiagnosticSeverity.ERROR,
                             source=DIAGNOSTICS_SOURCE_NAME,
@@ -117,7 +118,7 @@ async def _analyze_keyword_call(
                 if result.is_deprecated:
                     self._results.append(
                         Diagnostic(
-                            range=range_from_token_or_node(value, keyword_token),
+                            range=range_from_node_or_token(node, keyword_token),
                             message=f"Keyword '{result.name}' is deprecated"
                             f"{f': {result.deprecated_message}' if result.deprecated_message else ''}.",
                             severity=DiagnosticSeverity.HINT,
@@ -128,19 +129,35 @@ async def _analyze_keyword_call(
                 if result.is_error_handler:
                     self._results.append(
                         Diagnostic(
-                            range=range_from_token_or_node(value, keyword_token),
+                            range=range_from_node_or_token(node, keyword_token),
                             message=f"Keyword definition contains errors: {result.error_handler_message}",
                             severity=DiagnosticSeverity.ERROR,
                             source=DIAGNOSTICS_SOURCE_NAME,
                         )
                     )
 
+                try:
+                    if result.arguments is not None:
+                        result.arguments.resolve([v.value for v in argument_tokens], None)
+                except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
+                    raise
+                except BaseException as e:
+                    self._results.append(
+                        Diagnostic(
+                            range=range_from_node(node, True),
+                            message=str(e),
+                            severity=DiagnosticSeverity.ERROR,
+                            source=DIAGNOSTICS_SOURCE_NAME,
+                            code=type(e).__qualname__,
+                        )
+                    )
+
         except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
             self._results.append(
                 Diagnostic(
-                    range=range_from_token_or_node(value, keyword_token),
+                    range=range_from_node_or_token(node, keyword_token),
                     message=str(e),
                     severity=DiagnosticSeverity.ERROR,
                     source=DIAGNOSTICS_SOURCE_NAME,
@@ -149,7 +166,7 @@ async def _analyze_keyword_call(
             )
 
         if result is not None and analyse_run_keywords:
-            await self._analyse_run_keyword(result, value, argument_tokens)
+            await self._analyse_run_keyword(result, node, argument_tokens)
 
         return result
 
@@ -336,7 +353,7 @@ async def visit_KeywordCall(self, node: ast.AST) -> None:  # noqa: N802
         if value.assign and not value.keyword:
             self._results.append(
                 Diagnostic(
-                    range=range_from_token_or_node(value, value.get_token(RobotToken.ASSIGN)),
+                    range=range_from_node_or_token(value, value.get_token(RobotToken.ASSIGN)),
                     message="Keyword name cannot be empty.",
                     severity=DiagnosticSeverity.ERROR,
                     source=DIAGNOSTICS_SOURCE_NAME,
@@ -351,7 +368,7 @@ async def visit_KeywordCall(self, node: ast.AST) -> None:  # noqa: N802
         if not self.current_testcase_or_keyword_name:
             self._results.append(
                 Diagnostic(
-                    range=range_from_token_or_node(value, value.get_token(RobotToken.ASSIGN)),
+                    range=range_from_node_or_token(value, value.get_token(RobotToken.ASSIGN)),
                     message="Code is unreachable.",
                     severity=DiagnosticSeverity.HINT,
                     source=DIAGNOSTICS_SOURCE_NAME,
@@ -371,7 +388,7 @@ async def visit_TestCase(self, node: ast.AST) -> None:  # noqa: N802
             name_token = cast(TestCaseName, testcase.header).get_token(RobotToken.TESTCASE_NAME)
             self._results.append(
                 Diagnostic(
-                    range=range_from_token_or_node(testcase, name_token),
+                    range=range_from_node_or_token(testcase, name_token),
                     message="Test case name cannot be empty.",
                     severity=DiagnosticSeverity.ERROR,
                     source=DIAGNOSTICS_SOURCE_NAME,
@@ -398,7 +415,7 @@ async def visit_Keyword(self, node: ast.AST) -> None:  # noqa: N802
             ):
                 self._results.append(
                     Diagnostic(
-                        range=range_from_token_or_node(keyword, name_token),
+                        range=range_from_node_or_token(keyword, name_token),
                         message="Keyword cannot have both normal and embedded arguments.",
                         severity=DiagnosticSeverity.ERROR,
                         source=DIAGNOSTICS_SOURCE_NAME,
@@ -409,7 +426,7 @@ async def visit_Keyword(self, node: ast.AST) -> None:  # noqa: N802
             name_token = cast(KeywordName, keyword.header).get_token(RobotToken.KEYWORD_NAME)
             self._results.append(
                 Diagnostic(
-                    range=range_from_token_or_node(keyword, name_token),
+                    range=range_from_node_or_token(keyword, name_token),
                     message="Keyword name cannot be empty.",
                     severity=DiagnosticSeverity.ERROR,
                     source=DIAGNOSTICS_SOURCE_NAME,

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -261,6 +261,69 @@ def __str__(self) -> str:
 DEPRECATED_PATTERN = re.compile(r"^\*DEPRECATED(?P<message>.*)\*(?P<doc>.*)")
 
 
+@dataclass
+class ArgumentSpec:
+    name: str
+    type: Any
+    positional_only: Any
+    positional_or_named: Any
+    var_positional: Any
+    named_only: Any
+    var_named: Any
+    defaults: Any
+    types: Any
+
+    __robot_arguments: Optional[Any] = None
+
+    @staticmethod
+    def from_robot_argument_spec(spec: Any) -> ArgumentSpec:
+        return ArgumentSpec(
+            name=spec.name,
+            type=spec.type,
+            positional_only=spec.positional_only,
+            positional_or_named=spec.positional_or_named,
+            var_positional=spec.var_positional,
+            named_only=spec.named_only,
+            var_named=spec.var_named,
+            defaults={k: str(v) for k, v in spec.defaults.items()} if spec.defaults else {},
+            types=None,
+        )
+
+    def resolve(
+        self,
+        arguments: Any,
+        variables: Any,
+        resolve_named: bool = True,
+        resolve_variables_until: Any = None,
+        dict_to_kwargs: bool = False,
+    ) -> Any:
+        from robot.running.arguments.argumentresolver import ArgumentResolver
+        from robot.running.arguments.argumentspec import (
+            ArgumentSpec as RobotArgumentSpec,
+        )
+
+        if self.__robot_arguments is None:
+            self.__robot_arguments = RobotArgumentSpec(
+                self.name,
+                self.type,
+                self.positional_only,
+                self.positional_or_named,
+                self.var_positional,
+                self.named_only,
+                self.var_named,
+                self.defaults,
+                self.types,
+            )
+
+        resolver = ArgumentResolver(
+            self.__robot_arguments,
+            resolve_named=resolve_named,
+            resolve_variables_until=resolve_variables_until,
+            dict_to_kwargs=dict_to_kwargs,
+        )
+        resolver.resolve(arguments, variables)
+
+
 @dataclass
 class KeywordDoc(Model):
     name: str = ""
@@ -282,6 +345,7 @@ class KeywordDoc(Model):
     is_registered_run_keyword: bool = False
     args_to_process: Optional[int] = None
     deprecated: bool = False
+    arguments: Optional[ArgumentSpec] = None
 
     def __str__(self) -> str:
         return f"{self.name}({', '.join(str(arg) for arg in self.args)})"
@@ -1208,6 +1272,7 @@ def get_test_library(
                             longname=f"{libdoc.name}.{kw[0].name}",
                             doc_format=str(lib.doc_format) or DEFAULT_DOC_FORMAT,
                             is_initializer=True,
+                            arguments=ArgumentSpec.from_robot_argument_spec(kw[1].arguments),
                         )
                         for kw in [
                             (KeywordDocBuilder().build_keyword(k), k) for k in [KeywordWrapper(lib.init, source)]
@@ -1249,6 +1314,7 @@ def get_test_library(
                             is_registered_run_keyword=RUN_KW_REGISTER.is_run_keyword(libdoc.name, kw[0].name),
                             args_to_process=RUN_KW_REGISTER.get_args_to_process(libdoc.name, kw[0].name),
                             deprecated=kw[0].deprecated,
+                            arguments=ArgumentSpec.from_robot_argument_spec(kw[1].arguments),
                         )
                         for kw in [
                             (KeywordDocBuilder().build_keyword(k), k)

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -915,6 +915,7 @@ async def _import(value: Import) -> Optional[LibraryEntry]:
             except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
                 raise
             except BaseException as e:
+                self._logger.exception(e)
                 if top_level:
                     self._diagnostics.append(
                         Diagnostic(

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -10,7 +10,7 @@
 from ...common.lsp_types import Diagnostic, DiagnosticSeverity, Position, Range
 from ...common.parts.diagnostics import DiagnosticsResult
 from ...common.text_document import TextDocument
-from ..utils.ast import Token, range_from_token
+from ..utils.ast import Token, range_from_node, range_from_token
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
@@ -77,10 +77,7 @@ async def collect_namespace_diagnostics(
 
     def _create_error_from_node(self, node: ast.AST, msg: str, source: Optional[str] = None) -> Diagnostic:
         return Diagnostic(
-            range=Range(
-                start=Position(line=node.lineno - 1, character=node.col_offset),
-                end=Position(line=(node.end_lineno or 1) - 1, character=node.end_col_offset or 0),
-            ),
+            range=range_from_node(node, True),
             message=msg,
             severity=DiagnosticSeverity.ERROR,
             source=source if source is not None else self.source_name,

robotcode/language_server/robotframework/parts/references.py

@@ -45,8 +45,8 @@
     get_tokens_at_position,
     is_not_variable_token,
     iter_over_keyword_names_and_owners,
+    range_from_node_or_token,
     range_from_token,
-    range_from_token_or_node,
     tokenize_variables,
 )
 from ..utils.async_ast import iter_nodes
@@ -282,7 +282,7 @@ async def references_KeywordName(  # noqa: N802
         if keyword is not None and keyword.source and not keyword.is_error_handler:
             return [
                 *(
-                    [Location(uri=str(Uri.from_path(keyword.source)), range=range_from_token_or_node(node, name_token))]
+                    [Location(uri=str(Uri.from_path(keyword.source)), range=range_from_node_or_token(node, name_token))]
                     if context.include_declaration
                     else []
                 ),

robotcode/language_server/robotframework/utils/ast.py

@@ -32,16 +32,6 @@ def iter_nodes(node: ast.AST) -> Generator[ast.AST, None, None]:
             yield from iter_nodes(value)
 
 
-def range_from_node(node: ast.AST) -> Range:
-    return Range(
-        start=Position(line=node.lineno - 1, character=node.col_offset),
-        end=Position(
-            line=node.end_lineno - 1 if node.end_lineno is not None else -1,
-            character=node.end_col_offset if node.end_col_offset is not None else -1,
-        ),
-    )
-
-
 @runtime_checkable
 class Token(Protocol):
     type: Optional[str]
@@ -114,6 +104,24 @@ def range_from_token(token: Token) -> Range:
     )
 
 
+def range_from_node(node: ast.AST, skip_non_data: bool = False) -> Range:
+    from robot.parsing.lexer import Token as RobotToken
+
+    if skip_non_data and isinstance(node, HasTokens) and node.tokens:
+        start_token = next((v for v in node.tokens if v.type not in RobotToken.NON_DATA_TOKENS), None)
+        end_token = next((v for v in reversed(node.tokens) if v.type not in RobotToken.NON_DATA_TOKENS), None)
+        if start_token is not None and end_token is not None:
+            return Range(start=range_from_token(start_token).start, end=range_from_token(end_token).end)
+
+    return Range(
+        start=Position(line=node.lineno - 1, character=node.col_offset),
+        end=Position(
+            line=node.end_lineno - 1 if node.end_lineno is not None else -1,
+            character=node.end_col_offset if node.end_col_offset is not None else -1,
+        ),
+    )
+
+
 def token_in_range(token: Token, range: Range) -> bool:
     token_range = range_from_token(token)
     return token_range.start.is_in_range(range) or token_range.end.is_in_range(range)
@@ -124,11 +132,11 @@ def node_in_range(node: ast.AST, range: Range) -> bool:
     return node_range.start.is_in_range(range) or node_range.end.is_in_range(range)
 
 
-def range_from_token_or_node(node: ast.AST, token: Optional[Token]) -> Range:
+def range_from_node_or_token(node: ast.AST, token: Optional[Token]) -> Range:
     if token is not None:
         return range_from_token(token)
     if node is not None:
-        return range_from_node(node)
+        return range_from_node(node, True)
     return Range.zero()
 
 

tests/robotcode/language_server/robotframework/parts/data/lib/alibrary.py

@@ -10,3 +10,8 @@ def __init__(self, a_param: Any = None) -> None:
     def a_library_keyword(self) -> Any:
         logger.info("hello from a_library")
         return self.a_param
+
+    def a_library_keywords_with_args(self, i: int, b: bool) -> Any:
+        print(i)
+        print(b)
+        return (i, b)