start implementing references codelens

Author: d-biehl

robotcode/language_server/common/lsp_types.py

@@ -1633,6 +1633,7 @@ class _CodeLensParams(Model):
     text_document: TextDocumentIdentifier
 
 
+@dataclass(repr=False)
 class CodeLensParams(WorkDoneProgressParams, PartialResultParams, _CodeLensParams):
     pass
 

robotcode/language_server/robotframework/parts/codelens.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING, Any, List, Optional, cast
+
+from ....utils.async_tools import run_coroutine_in_thread
+from ....utils.logging import LoggingDescriptor
+from ...common.language import language_id
+from ...common.lsp_types import CodeLens, Command
+from ...common.text_document import TextDocument
+from ..utils.ast import range_from_token
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol
+
+from .protocol_part import RobotLanguageServerProtocolPart
+
+
+class RobotCodeLensProtocolPart(RobotLanguageServerProtocolPart):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: RobotLanguageServerProtocol) -> None:
+        super().__init__(parent)
+
+        # parent.code_lens.collect.add(self.collect)
+
+    @language_id("robotframework")
+    async def collect(self, sender: Any, document: TextDocument) -> Optional[List[CodeLens]]:
+
+        from ..utils.async_ast import AsyncVisitor
+
+        class Visitor(AsyncVisitor):
+            def __init__(self, parent: RobotCodeLensProtocolPart) -> None:
+                super().__init__()
+                self.parent = parent
+
+                self.result: List[CodeLens] = []
+
+            async def visit(self, node: ast.AST) -> None:
+                await super().visit(node)
+
+            @classmethod
+            async def find_from(cls, model: ast.AST, parent: RobotCodeLensProtocolPart) -> Optional[List[CodeLens]]:
+
+                finder = cls(parent)
+
+                await finder.visit(model)
+
+                return finder.result if finder.result else None
+
+            async def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
+                from robot.parsing.model.blocks import KeywordSection
+
+                if isinstance(node, KeywordSection):
+                    await self.generic_visit(node)
+
+            async def visit_Keyword(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}],
+                            ),
+                        )
+                    )
+
+        async def run() -> Optional[List[CodeLens]]:
+            return await Visitor.find_from(await self.parent.documents_cache.get_model(document), self)
+
+        return await run_coroutine_in_thread(run)

robotcode/language_server/robotframework/parts/folding_range.py

@@ -3,7 +3,7 @@
 import ast
 from typing import TYPE_CHECKING, Any, List, Optional, cast
 
-from ....utils.async_tools import check_canceled, run_coroutine_in_thread
+from ....utils.async_tools import run_coroutine_in_thread
 from ....utils.logging import LoggingDescriptor
 from ...common.language import language_id
 from ...common.lsp_types import FoldingRange
@@ -47,7 +47,6 @@ def __init__(self, parent: RobotFoldingRangeProtocolPart) -> None:
                 self.result: List[FoldingRange] = []
 
             async def visit(self, node: ast.AST) -> None:
-                await check_canceled()
                 await super().visit(node)
 
             @classmethod

robotcode/language_server/robotframework/protocol.py

@@ -20,6 +20,7 @@
 )
 from ..common.parts.document_symbols import symbol_information_label
 from ..common.protocol import LanguageServerProtocol
+from .parts.codelens import RobotCodeLensProtocolPart
 from .parts.completion import RobotCompletionProtocolPart
 from .parts.diagnostics import RobotDiagnosticsProtocolPart
 from .parts.discovering import DiscoveringProtocolPart
@@ -88,6 +89,7 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
     robot_discovering = ProtocolPartDescriptor(DiscoveringProtocolPart)
     robot_semantic_tokens = ProtocolPartDescriptor(RobotSemanticTokenProtocolPart)
     robot_references = ProtocolPartDescriptor(RobotReferencesProtocolPart)
+    robot_codelens = ProtocolPartDescriptor(RobotCodeLensProtocolPart)
     robot_workspace = ProtocolPartDescriptor(RobotWorkspaceProtocolPart)
 
     name = "RobotCode"