implement reference codelenses for keyword definitions

Author: d-biehl

CHANGELOG.md

@@ -500,6 +500,11 @@
             "default": 1000,
             "description": "Specifies the maximum number of files for which diagnostics are reported for the whole project/workspace folder. Specifies 0 or less to disable the limit completely.",
             "scope": "resource"
+          },
+          "robotcode.analysis.referencesCodeLens": {
+            "type": "boolean",
+            "default": true,
+            "description": "Enable/disable references CodeLens for RobotFramework files."
           }
         }
       }

package.json

@@ -78,7 +78,7 @@ async def _code_lens_resolve(self, params: CodeLens, *args: Any, **kwargs: Any)
                 if result is not None:
                     results.append(result)
 
-        if len(results) > 0:
+        if len(results) > 1:
             self._logger.warning("More then one resolve result collected.")
             return results[-1]
 

robotcode/language_server/common/parts/code_lens.py

@@ -82,6 +82,7 @@ class AnalysisConfig(ConfigBase):
     diagnostic_mode: DiagnosticsMode = DiagnosticsMode.OPENFILESONLY
     progress_mode: AnalysisProgressMode = AnalysisProgressMode.SIMPLE
     max_project_file_count: int = 1000
+    references_code_lens: bool = True
 
 
 @config_section("robotcode")

robotcode/language_server/robotframework/configuration.py

@@ -8,21 +8,24 @@
 from ...common.decorators import language_id
 from ...common.lsp_types import CodeLens, Command
 from ...common.text_document import TextDocument
+from ..configuration import AnalysisConfig
 from ..utils.ast_utils import range_from_token
+from .model_helper import ModelHelperMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 from .protocol_part import RobotLanguageServerProtocolPart
 
 
-class RobotCodeLensProtocolPart(RobotLanguageServerProtocolPart):
+class RobotCodeLensProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         super().__init__(parent)
 
-        # parent.code_lens.collect.add(self.collect)
+        parent.code_lens.collect.add(self.collect)
+        parent.code_lens.resolve.add(self.resolve)
 
     @language_id("robotframework")
     @threaded()
@@ -55,27 +58,70 @@ async def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
                 if isinstance(node, KeywordSection):
                     await self.generic_visit(node)
 
-            async def visit_Keyword(self, node: ast.AST) -> None:  # noqa: N802
+            async def visit_KeywordName(self, node: ast.AST) -> None:  # noqa: N802
                 from robot.parsing.lexer.tokens import Token as RobotToken
-                from robot.parsing.model.blocks import Keyword
-
-                keyword = cast(Keyword, node)
-
-                if keyword.header:
-                    name_token = keyword.header.get_token(RobotToken.KEYWORD_NAME)
-                    if name_token is None:
-                        return
-
-                    r = range_from_token(name_token)
-                    self.result.append(
-                        CodeLens(
-                            r,
-                            Command(
-                                "references",
-                                "robotcode.action.findReferences",
-                                [str(document.uri), {"lineNumber": r.start.line, "column": r.start.character}],
-                            ),
-                        )
+                from robot.parsing.model.statements import KeywordName
+
+                kw_node = cast(KeywordName, node)
+                name_token = cast(RobotToken, kw_node.get_token(RobotToken.KEYWORD_NAME))
+                if not name_token:
+                    return None
+
+                self.result.append(
+                    CodeLens(
+                        range_from_token(name_token),
+                        command=None,
+                        data={"uri": str(document.uri), "name": name_token.value, "line": name_token.lineno},
                     )
+                )
+
+        if not (await self.parent.workspace.get_configuration(AnalysisConfig, document.uri)).references_code_lens:
+            return None
 
         return await Visitor.find_from(await self.parent.documents_cache.get_model(document), self)
+
+    async def resolve(self, sender: Any, code_lens: CodeLens) -> Optional[CodeLens]:
+        if code_lens.data is None:
+            return code_lens
+
+        document = await self.parent.documents.get(code_lens.data.get("uri", None))
+        if document is None:
+            return None
+
+        if not (await self.parent.workspace.get_configuration(AnalysisConfig, document.uri)).references_code_lens:
+            return None
+
+        namespace = await self.parent.documents_cache.get_namespace(document)
+
+        if namespace is None:
+            return None
+
+        name = code_lens.data["name"]
+        line = code_lens.data["line"]
+
+        if self.parent.robot_workspace.workspace_loaded:
+            kw_doc = await self.get_keyword_definition_at_line(namespace, name, line)
+
+            if kw_doc is not None and not kw_doc.is_error_handler:
+                references = await self.parent.robot_references.find_keyword_references(
+                    document, kw_doc, include_declaration=False
+                )
+                code_lens.command = Command(
+                    f"{len(references)} references",
+                    "editor.action.showReferences",
+                    [str(document.uri), code_lens.range.start, references],
+                )
+            else:
+                code_lens.command = Command(
+                    "0 references",
+                    "editor.action.showReferences",
+                    [str(document.uri), code_lens.range.start, []],
+                )
+        else:
+            code_lens.command = Command(
+                "...",
+                "editor.action.showReferences",
+                [str(document.uri), code_lens.range.start, []],
+            )
+
+        return code_lens

robotcode/language_server/robotframework/parts/codelens.py

@@ -519,7 +519,11 @@ def is_bdd_token(cls, token: Token) -> bool:
 
     @classmethod
     async def get_keyword_definition_at_token(cls, namespace: Namespace, token: Token) -> Optional[KeywordDoc]:
+        return await cls.get_keyword_definition_at_line(namespace, token.value, token.lineno)
+
+    @classmethod
+    async def get_keyword_definition_at_line(cls, namespace: Namespace, value: str, line: int) -> Optional[KeywordDoc]:
         return next(
-            (k for k in (await namespace.get_library_doc()).keywords.get_all(token.value) if k.line_no == token.lineno),
+            (k for k in (await namespace.get_library_doc()).keywords.get_all(value) if k.line_no == line),
             None,
         )

robotcode/language_server/robotframework/parts/model_helper.py

@@ -358,7 +358,7 @@ async def references_KeywordName(  # noqa: N802
             keyword = await self.get_keyword_definition_at_token(namespace, name_token)
 
             if keyword is not None and keyword.source and not keyword.is_error_handler:
-                return await self.find_keyword_references(document, keyword, context.include_declaration)
+                return await self.find_keyword_references(document, keyword, False)
 
         return None
 
@@ -595,7 +595,7 @@ async def get_keyword_references_from_tokens(
     ) -> AsyncGenerator[Location, None]:
         from robot.utils.escaping import unescape
 
-        if kw_token is not None and is_not_variable_token(kw_token):
+        if kw_token is not None:
             kw_token = self.strip_bdd_prefix(kw_token)
 
             kw: Optional[KeywordDoc] = None

robotcode/language_server/robotframework/parts/references.py

@@ -28,8 +28,9 @@ class RobotWorkspaceProtocolPart(RobotLanguageServerProtocolPart):
     def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         super().__init__(parent)
         self.parent.documents.on_read_document_text.add(self._on_read_document_text)
-        self.parent.diagnostics.collect_workspace_documents.add(self.collect_workspace_diagnostics)
+        self.parent.diagnostics.collect_workspace_documents.add(self._collect_workspace_documents)
         self.parent.diagnostics.on_get_diagnostics_mode.add(self.on_get_diagnostics_mode)
+        self.workspace_loaded = False
 
     @language_id("robotframework")
     async def _on_read_document_text(self, sender: Any, uri: Uri) -> Optional[str]:
@@ -43,7 +44,7 @@ async def on_get_diagnostics_mode(self, sender: Any, uri: Uri) -> Optional[Diagn
         return config.diagnostic_mode
 
     @threaded()
-    async def collect_workspace_diagnostics(self, sender: Any) -> List[WorkspaceDocumentsResult]:
+    async def _collect_workspace_documents(self, sender: Any) -> List[WorkspaceDocumentsResult]:
 
         result: List[WorkspaceDocumentsResult] = []
 
@@ -100,6 +101,10 @@ async def collect_workspace_diagnostics(self, sender: Any) -> List[WorkspaceDocu
                     except BaseException as e:
                         self._logger.exception(e)
 
+        self.workspace_loaded = True
+        if config.analysis.references_code_lens:
+            await self.parent.code_lens.refresh()
+
         if canceled:
             return []
 

robotcode/language_server/robotframework/parts/robot_workspace.py

@@ -689,6 +689,19 @@ def create_sub_task(
     return result
 
 
+def create_delayed_sub_task(
+    coro: Awaitable[_T], *, delay: float, name: Optional[str] = None, loop: Optional[asyncio.AbstractEventLoop] = None
+) -> asyncio.Task[Optional[_T]]:
+    async def run() -> Optional[_T]:
+        try:
+            await asyncio.sleep(delay)
+            return await coro
+        except asyncio.CancelledError:
+            return None
+
+    return create_sub_task(run(), name=name, loop=loop)
+
+
 def create_sub_future(loop: Optional[asyncio.AbstractEventLoop] = None) -> asyncio.Future[Any]:
 
     ct = get_current_future_info()

robotcode/utils/async_tools.py

@@ -13,7 +13,7 @@
         }
     },
     "robotcode.languageServer.args": [
-        "--debugpy",
+        // "--debugpy",
         // "--log",
         // "--log-level",
         // "TRACE",