implement references for keywords, close #13, correct analyzing "run keywords"

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -611,9 +611,9 @@ async def _analyse_run_keyword(
             await self._analyze_keyword_call(argument_tokens[1].value, node, argument_tokens[1], argument_tokens[2:])
             return argument_tokens[2:]
         elif keyword_doc.is_run_keywords():
-
+            has_and = False
             while argument_tokens:
-                # TODO: Parse "run keywords" with arguments using upper case AND
+
                 t = argument_tokens[0]
                 argument_tokens = argument_tokens[1:]
                 if t.value == "AND":
@@ -635,6 +635,10 @@ async def _analyse_run_keyword(
                 if and_token is not None:
                     args = argument_tokens[: argument_tokens.index(and_token)]
                     argument_tokens = argument_tokens[argument_tokens.index(and_token) + 1 :]
+                    has_and = True
+                elif has_and:
+                    args = argument_tokens
+                    argument_tokens = []
 
                 await self._analyze_keyword_call(t.value, node, t, args)
 

robotcode/language_server/robotframework/parts/model_helper.py

@@ -38,20 +38,31 @@ async def get_run_keyword_keyworddoc_and_token_from_position(
             return result, argument_tokens[2:]
 
         elif keyword_doc.is_run_keywords():
+            has_and = False
             while argument_tokens:
                 t = argument_tokens[0]
                 argument_tokens = argument_tokens[1:]
                 if t.value == "AND":
                     continue
 
-                if is_not_variable_token(t) and position.is_in_range(range_from_token(t)):
-                    result = await self.get_keyworddoc_and_token_from_position(t.value, t, [], namespace, position)
+                and_token = next((e for e in argument_tokens if e.value == "AND"), None)
+                if and_token is not None:
+                    args = argument_tokens[: argument_tokens.index(and_token)]
+                    has_and = True
+                else:
+                    if has_and:
+                        args = argument_tokens
+                    else:
+                        args = []
 
-                    return result, argument_tokens
+                result = await self.get_keyworddoc_and_token_from_position(t.value, t, args, namespace, position)
+                if result is not None and result[0] is not None:
+                    return result, []
 
-                and_token = next((e for e in argument_tokens if e.value == "AND"), None)
                 if and_token is not None:
                     argument_tokens = argument_tokens[argument_tokens.index(and_token) + 1 :]
+                elif has_and:
+                    argument_tokens = []
 
             return None, []
         elif keyword_doc.is_run_keyword_if() and len(argument_tokens) > 1 and is_not_variable_token(argument_tokens[1]):

robotcode/language_server/robotframework/parts/references.py

@@ -6,6 +6,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncGenerator,
     Awaitable,
     Callable,
     Iterator,
@@ -25,12 +26,21 @@
 from ...common.lsp_types import Location, Position, ReferenceContext
 from ...common.text_document import TextDocument
 from ..configuration import WorkspaceConfig
-from ..diagnostics.library_doc import KeywordDoc, KeywordMatcher, LibraryDoc
+from ..diagnostics.library_doc import (
+    ALL_RUN_KEYWORDS_MATCHERS,
+    RESOURCE_FILE_EXTENSION,
+    ROBOT_FILE_EXTENSION,
+    KeywordDoc,
+    KeywordMatcher,
+    LibraryDoc,
+)
+from ..diagnostics.namespace import Namespace
 from ..utils.ast import (
     HasTokens,
     Token,
     get_nodes_at_position,
     get_tokens_at_position,
+    is_not_variable_token,
     range_from_token,
     range_from_token_or_node,
     tokenize_variables,
@@ -289,13 +299,6 @@ async def _find_keyword_references_in_file(
         file: Path,
         cancel_token: CancelationToken,
     ) -> List[Location]:
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import (
-            Fixture,
-            KeywordCall,
-            Template,
-            TestTemplate,
-        )
 
         doc = self.parent.robot_workspace.get_or_open_document(file, "robotframework")
         namespace = await self.parent.documents_cache.get_namespace(doc, cancelation_token=cancel_token)
@@ -310,47 +313,129 @@ async def _find_keyword_references_in_file(
         ):
             return []
 
-        libraries_matchers = (await namespace.get_libraries_matchers()).keys()
-        resources_matchers = (await namespace.get_resources_matchers()).keys()
+        return await asyncio.get_running_loop().run_in_executor(
+            None, asyncio.run, self._find_keyword_references_in_namespace(namespace, kw_doc, cancel_token)
+        )
+
+    async def _find_keyword_references_in_namespace(
+        self, namespace: Namespace, kw_doc: KeywordDoc, cancel_token: CancelationToken
+    ) -> List[Location]:
+        from robot.parsing.lexer.tokens import Token as RobotToken
+        from robot.parsing.model.statements import (
+            Fixture,
+            KeywordCall,
+            Template,
+            TestTemplate,
+        )
+
+        result: List[Location] = []
+
+        async for node in iter_nodes(namespace.model):
+            cancel_token.throw_if_canceled()
+
+            kw_token: Optional[Token] = None
+            arguments: Optional[List[Token]] = None
 
-        async def _run() -> List[Location]:
+            if isinstance(node, KeywordCall):
+                kw_token = node.get_token(RobotToken.KEYWORD)
+                arguments = list(node.get_tokens(RobotToken.ARGUMENT) or [])
+            elif isinstance(node, Fixture):
+                kw_token = node.get_token(RobotToken.NAME)
+                arguments = list(node.get_tokens(RobotToken.ARGUMENT) or [])
+            elif isinstance(node, (Template, TestTemplate)):
+                kw_token = node.get_token(RobotToken.NAME)
+                arguments = list(node.get_tokens(RobotToken.ARGUMENT) or [])
+
+            async for location in self.get_keyword_references_from_tokens(namespace, kw_doc, node, kw_token, arguments):
+                result.append(location)
+
+        return result
+
+    async def get_keyword_references_from_tokens(
+        self,
+        namespace: Namespace,
+        kw_doc: KeywordDoc,
+        node: ast.AST,
+        kw_token: Optional[Token],
+        arguments: Optional[List[Token]],
+    ) -> AsyncGenerator[Location, None]:
+        if kw_token is not None and is_not_variable_token(kw_token):
+            kw: Optional[KeywordDoc] = None
             kw_matcher = KeywordMatcher(kw_doc.name)
 
-            result: List[Location] = []
-
-            async for node in iter_nodes(namespace.model):
-                cancel_token.throw_if_canceled()
-
-                kw: Optional[KeywordDoc] = None
-                kw_token: Optional[Token] = None
-
-                if isinstance(node, KeywordCall):
-                    kw_token = node.get_token(RobotToken.KEYWORD)
-                elif isinstance(node, Fixture):
-                    kw_token = node.get_token(RobotToken.NAME)
-                elif isinstance(node, (Template, TestTemplate)):
-                    kw_token = node.get_token(RobotToken.NAME)
-
-                if kw_token is not None:
-                    for lib, name in self._yield_owner_and_kw_names(kw_token.value):
-                        if lib is not None:
-                            lib_matcher = KeywordMatcher(lib)
-                            if lib_matcher not in libraries_matchers and lib_matcher not in resources_matchers:
-                                continue
-
-                        if kw_matcher == name:
-                            kw = await namespace.find_keyword(str(kw_token.value))
-
-                            if kw is not None and kw == kw_doc:
-                                result.append(
-                                    Location(
-                                        str(Uri.from_path(namespace.source).normalized()),
-                                        range=range_from_token_or_node(node, kw_token),
-                                    )
-                                )
-            return result
+            for lib, name in self._yield_owner_and_kw_names(kw_token.value):
+                if lib is not None:
+                    lib_matcher = KeywordMatcher(lib)
+                    if (
+                        lib_matcher not in (await namespace.get_libraries_matchers()).keys()
+                        and lib_matcher not in (await namespace.get_resources_matchers()).keys()
+                    ):
+                        continue
+
+                if name is not None:
+                    name_matcher = KeywordMatcher(name)
+                    if kw_matcher == name_matcher:
+                        kw = await namespace.find_keyword(str(kw_token.value))
+
+                        if kw is not None and kw == kw_doc:
+                            yield Location(
+                                str(Uri.from_path(namespace.source).normalized()),
+                                range=range_from_token_or_node(node, kw_token),
+                            )
+
+                    if name_matcher in ALL_RUN_KEYWORDS_MATCHERS and arguments:
+                        async for location in self.get_keyword_references_from_any_run_keyword(
+                            namespace, kw_doc, node, kw_token, arguments
+                        ):
+                            yield location
+
+    async def get_keyword_references_from_any_run_keyword(
+        self,
+        namespace: Namespace,
+        kw_doc: KeywordDoc,
+        node: ast.AST,
+        kw_token: Token,
+        arguments: List[Token],
+    ) -> AsyncGenerator[Location, None]:
+
+        if kw_token is None or is_not_variable_token(kw_token):
+            return
+
+        kw = await namespace.find_keyword(str(kw_token.value))
+
+        if kw is None or not kw.is_any_run_keyword():
+            return
+
+        if kw.is_run_keyword() and len(arguments) > 0 and is_not_variable_token(arguments[0]):
+            async for e in self.get_keyword_references_from_tokens(
+                namespace, kw_doc, node, arguments[0], arguments[1:]
+            ):
+                yield e
+        elif kw.is_run_keyword_with_condition() and len(arguments) > 1 and is_not_variable_token(arguments[1]):
+            async for e in self.get_keyword_references_from_tokens(
+                namespace, kw_doc, node, arguments[1], arguments[2:]
+            ):
+                yield e
+        elif kw.is_run_keywords():
+
+            while arguments:
+
+                t = arguments[0]
+                arguments = arguments[1:]
+                if t.value == "AND":
+                    continue
+
+                if not is_not_variable_token(t):
+                    continue
+
+                and_token = next((e for e in arguments if e.value == "AND"), None)
+                args = []
+                if and_token is not None:
+                    args = arguments[: arguments.index(and_token)]
+                    arguments = arguments[arguments.index(and_token) + 1 :]
 
-        return await asyncio.get_running_loop().run_in_executor(None, asyncio.run, _run())
+                async for e in self.get_keyword_references_from_tokens(namespace, kw_doc, node, t, args):
+                    yield e
 
     async def _find_keyword_references(self, document: TextDocument, kw_doc: KeywordDoc) -> List[Location]:
         folder = self.parent.workspace.get_workspace_folder(document.uri)
@@ -391,7 +476,7 @@ async def _find_keyword_references(self, document: TextDocument, kw_doc: Keyword
 
             async for f in iter_files(
                 folder.uri.to_path(),
-                ("**/*.{robot,resource}"),
+                (f"**/*.{{{ROBOT_FILE_EXTENSION[1:]},{RESOURCE_FILE_EXTENSION[1:]}}}"),
                 ignore_patterns=config.exclude_patterns or [],  # type: ignore
                 absolute=True,
             ):