refactor: prepare create keywords quickfix

d-biehl · d-biehl · commit b34c8bfa80be · 2023-01-15T23:31:45.000+01:00
diff --git a/robotcode/language_server/common/decorators.py b/robotcode/language_server/common/decorators.py
@@ -83,7 +83,7 @@ def filter(c: Any) -> bool:
 
 @runtime_checkable
 class IsCommand(Protocol):
-    __command_name__: List[str]
+    __command_name__: str
 
 
 def command(name: str) -> Callable[[_F], _F]:
diff --git a/robotcode/language_server/common/parts/commands.py b/robotcode/language_server/common/parts/commands.py
@@ -1,13 +1,16 @@
 from __future__ import annotations
 
+import inspect
+import typing
 import uuid
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, List, Optional, cast
 
 from ....jsonrpc2.protocol import JsonRPCErrorException, rpc_method
 from ....utils.async_tools import threaded
+from ....utils.dataclasses import from_dict
 from ....utils.logging import LoggingDescriptor
-from ..decorators import get_command_name
+from ..decorators import IsCommand, get_command_name
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..lsp_types import (
     ErrorCodes,
@@ -53,6 +56,14 @@ def register(self, callback: _FUNC_TYPE, name: Optional[str] = None) -> str:
 
         return command
 
+    def register_all(self, instance: object) -> None:
+        all_methods = [
+            getattr(instance, k) for k, v in type(instance).__dict__.items() if callable(v) and not k.startswith("_")
+        ]
+        for method in all_methods:
+            if isinstance(method, IsCommand):
+                self.register(cast(_FUNC_TYPE, method))
+
     def get_command_name(self, callback: _FUNC_TYPE, name: Optional[str] = None) -> str:
         name = name or get_command_name(callback)
 
@@ -73,4 +84,15 @@ async def _workspace_execute_command(
         if entry is None or entry.callback is None:
             raise JsonRPCErrorException(ErrorCodes.INVALID_PARAMS, f"Command '{command}' unknown.")
 
-        return await entry.callback(*(arguments or ()))
+        signature = inspect.signature(entry.callback)
+        type_hints = list(typing.get_type_hints(entry.callback).values())
+
+        command_args: List[Any] = []
+
+        if arguments:
+            for i, v in enumerate(signature.parameters.values()):
+
+                if i < len(arguments):
+                    command_args.append(from_dict(arguments[i], type_hints[i]))
+
+        return await entry.callback(*command_args)
diff --git a/robotcode/language_server/robotframework/diagnostics/namespace.py b/robotcode/language_server/robotframework/diagnostics/namespace.py
@@ -1724,7 +1724,9 @@ def find_keyword(
                     if result is None:
                         self.diagnostics.append(
                             DiagnosticsEntry(
-                                f"No keyword with name {repr(name)} found.", DiagnosticSeverity.ERROR, "KeywordError"
+                                f"No keyword with name {repr(name)} found.",
+                                DiagnosticSeverity.ERROR,
+                                "KeywordNotFoundError",
                             )
                         )
                 except KeywordError as e:
diff --git a/robotcode/language_server/robotframework/parts/code_action_documentation.py b/robotcode/language_server/robotframework/parts/code_action_documentation.py
@@ -16,12 +16,11 @@
 from ....utils.logging import LoggingDescriptor
 from ....utils.net import find_free_port
 from ....utils.uri import Uri
-from ...common.decorators import code_action_kinds, command, language_id
+from ...common.decorators import code_action_kinds, language_id
 from ...common.lsp_types import (
     CodeAction,
     CodeActionContext,
     CodeActionKinds,
-    CodeActionTriggerKind,
     Command,
     Model,
     Range,
@@ -175,10 +174,9 @@ def server_bind(self) -> None:
 
 
 CODEACTIONKINDS_SOURCE_OPENDOCUMENTATION = f"{CodeActionKinds.SOURCE}.openDocumentation"
-CODEACTIONKINDS_QUICKFIX_CREATEKEYWORD = f"{CodeActionKinds.QUICKFIX}.createKeyword"
 
 
-class RobotCodeActionProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin):
+class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: RobotLanguageServerProtocol) -> None:
@@ -192,7 +190,7 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         self._documentation_server_lock = threading.RLock()
         self._documentation_server_port = 0
 
-        self.parent.commands.register(self.comming_soon)
+        self.parent.commands.register_all(self)
 
     async def initialized(self, sender: Any) -> None:
         await self._ensure_http_server_started()
@@ -234,7 +232,6 @@ async def _ensure_http_server_started(self) -> None:
     @code_action_kinds(
         [
             CODEACTIONKINDS_SOURCE_OPENDOCUMENTATION,
-            CODEACTIONKINDS_QUICKFIX_CREATEKEYWORD,
         ]
     )
     @_logger.call
@@ -270,8 +267,6 @@ async def collect(
 
         if isinstance(node, (KeywordCall, Fixture, TestTemplate, Template)):
             # only source actions
-            if range.start != range.end:
-                return None
 
             result = await self.get_keyworddoc_and_token_from_position(
                 node.value
@@ -285,17 +280,8 @@ async def collect(
                 range.start,
             )
 
-            if result is None and (
-                (context.only and CodeActionKinds.QUICKFIX in context.only)
-                or context.trigger_kind == CodeActionTriggerKind.AUTOMATIC
-            ):
-                return [
-                    CodeAction(
-                        "Create Keyword",
-                        kind=CodeActionKinds.QUICKFIX + ".createKeyword",
-                        command=Command("Create Keyword", self.parent.commands.get_command_name(self.comming_soon)),
-                    )
-                ]
+            if range.start != range.end:
+                return None
 
             if result is not None:
                 kw_doc, _ = result
@@ -409,7 +395,3 @@ async def _convert_uri(self, uri: str, *args: Any, **kwargs: Any) -> Optional[st
             return f"http://localhost:{self._documentation_server_port}/{path.as_posix()}"
 
         return None
-
-    @command("robotcode.commingSoon")
-    async def comming_soon(self) -> None:
-        self.parent.window.show_message("Comming soon... stay tuned ...")
diff --git a/robotcode/language_server/robotframework/parts/code_action_fixes.py b/robotcode/language_server/robotframework/parts/code_action_fixes.py
@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING, Any, List, Optional, Union, cast
+
+from ....utils.logging import LoggingDescriptor
+from ...common.decorators import code_action_kinds, command, language_id
+from ...common.lsp_types import (
+    AnnotatedTextEdit,
+    ChangeAnnotation,
+    CodeAction,
+    CodeActionContext,
+    CodeActionKinds,
+    CodeActionTriggerKind,
+    Command,
+    DocumentUri,
+    OptionalVersionedTextDocumentIdentifier,
+    Position,
+    Range,
+    TextDocumentEdit,
+    WorkspaceEdit,
+)
+from ...common.text_document import TextDocument
+from ..utils.ast_utils import Token, get_node_at_position, range_from_node
+from ..utils.async_ast import AsyncVisitor
+from .model_helper import ModelHelperMixin
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol  # pragma: no cover
+
+from string import Template
+
+from .protocol_part import RobotLanguageServerProtocolPart
+
+CODEACTIONKINDS_QUICKFIX_CREATEKEYWORD = f"{CodeActionKinds.QUICKFIX}.createKeyword"
+
+
+KEYWORD_WITH_ARGS_TEMPLATE = Template(
+    """\n
+${name}
+    [Arguments]    ${args}
+    Fail    Not implemented
+"""
+)
+
+KEYWORD_TEMPLATE = Template(
+    """\n
+${name}
+    Fail    Not implemented
+"""
+)
+
+
+class FindKeywordSectionVisitor(AsyncVisitor):
+    def __init__(self) -> None:
+        self.keyword_sections: List[ast.AST] = []
+
+    async def visit_KeywordSection(self, node: ast.AST) -> None:  # noqa: N802
+        self.keyword_sections.append(node)
+
+
+async def find_keyword_sections(node: ast.AST) -> Optional[List[ast.AST]]:
+    visitor = FindKeywordSectionVisitor()
+    await visitor.visit(node)
+    return visitor.keyword_sections if visitor.keyword_sections else None
+
+
+class RobotCodeActionFixesProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: RobotLanguageServerProtocol) -> None:
+        super().__init__(parent)
+
+        parent.code_action.collect.add(self.collect)
+
+        self.parent.commands.register_all(self)
+
+    @language_id("robotframework")
+    @code_action_kinds(
+        [
+            CODEACTIONKINDS_QUICKFIX_CREATEKEYWORD,
+        ]
+    )
+    @_logger.call
+    async def collect(
+        self, sender: Any, document: TextDocument, range: Range, context: CodeActionContext
+    ) -> Optional[List[Union[Command, CodeAction]]]:
+
+        kw_not_found_in_diagnostics = next((d for d in context.diagnostics if d.code == "KeywordNotFoundError"), None)
+
+        if kw_not_found_in_diagnostics and (
+            (context.only and CodeActionKinds.QUICKFIX in context.only)
+            or context.trigger_kind in [CodeActionTriggerKind.INVOKED, CodeActionTriggerKind.AUTOMATIC]
+        ):
+            return [
+                CodeAction(
+                    "Create Keyword",
+                    kind=CodeActionKinds.QUICKFIX + ".createKeyword",
+                    command=Command(
+                        "Create Keyword",
+                        self.parent.commands.get_command_name(self.create_keyword),
+                        [document.document_uri, range, context],
+                    ),
+                    diagnostics=[kw_not_found_in_diagnostics],
+                )
+            ]
+
+        return None
+
+    @command("robotcode.createKeyword")
+    async def create_keyword(self, document_uri: DocumentUri, range: Range, context: CodeActionContext) -> None:
+        from robot.parsing.lexer import Token as RobotToken
+        from robot.parsing.model.statements import (
+            Fixture,
+            KeywordCall,
+            Template,
+            TestTemplate,
+        )
+        from robot.utils.escaping import split_from_equals
+
+        document = await self.parent.documents.get(document_uri)
+        if document is None:
+            return
+
+        namespace = await self.parent.documents_cache.get_namespace(document)
+        if namespace is None:
+            return None
+
+        model = await self.parent.documents_cache.get_model(document, False)
+        node = await get_node_at_position(model, range.start)
+
+        if isinstance(node, (KeywordCall, Fixture, TestTemplate, Template)):
+            keyword = (
+                node.value
+                if isinstance(node, (TestTemplate, Template))
+                else node.keyword
+                if isinstance(node, KeywordCall)
+                else node.name
+            )
+
+            arguments = []
+
+            for t in node.get_tokens(RobotToken.ARGUMENT):
+                name, value = split_from_equals(cast(Token, t).value)
+                if value is not None:
+                    arguments.append(f"${{{name}}}")
+                else:
+                    arguments.append(f"${{arg{len(arguments)+1}}}")
+
+            insert_text = (
+                KEYWORD_WITH_ARGS_TEMPLATE.substitute(name=keyword, args="    ".join(arguments))
+                if arguments
+                else KEYWORD_TEMPLATE.substitute(name=keyword)
+            )
+
+            keyword_sections = await find_keyword_sections(model)
+            keyword_section = keyword_sections[-1] if keyword_sections else None
+
+            if keyword_section is not None:
+                node_range = range_from_node(keyword_section)
+
+                insert_range = Range(node_range.end, node_range.end)
+            else:
+                insert_text = f"\n\n\n*** Keywords ***\n{insert_text}"
+                doc_pos = Position(len(document.get_lines()), 0)
+                insert_range = Range(doc_pos, doc_pos)
+
+            we = WorkspaceEdit(
+                document_changes=[
+                    TextDocumentEdit(
+                        OptionalVersionedTextDocumentIdentifier(str(document.uri), document.version),
+                        [AnnotatedTextEdit(insert_range, insert_text, annotation_id="create_keyword")],
+                    )
+                ],
+                change_annotations={"create_keyword": ChangeAnnotation("Create Keyword", False)},
+            )
+
+            await self.parent.workspace.apply_edit(we, "Rename Keyword")
diff --git a/robotcode/language_server/robotframework/protocol.py b/robotcode/language_server/robotframework/protocol.py
@@ -16,7 +16,8 @@
 from ..common.parts.document_symbols import symbol_information_label
 from ..common.protocol import LanguageServerProtocol
 from .configuration import RobotConfig
-from .parts.code_action import RobotCodeActionProtocolPart
+from .parts.code_action_documentation import RobotCodeActionDocumentationProtocolPart
+from .parts.code_action_fixes import RobotCodeActionFixesProtocolPart
 from .parts.codelens import RobotCodeLensProtocolPart
 from .parts.completion import RobotCompletionProtocolPart
 from .parts.debugging_utils import RobotDebuggingUtilsProtocolPart
@@ -96,7 +97,8 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
     robot_rename = ProtocolPartDescriptor(RobotRenameProtocolPart)
     robot_inline_value = ProtocolPartDescriptor(RobotInlineValueProtocolPart)
     robot_inlay_hint = ProtocolPartDescriptor(RobotInlayHintProtocolPart)
-    robot_code_action = ProtocolPartDescriptor(RobotCodeActionProtocolPart)
+    robot_code_action_documentation = ProtocolPartDescriptor(RobotCodeActionDocumentationProtocolPart)
+    robot_code_action_fixes = ProtocolPartDescriptor(RobotCodeActionFixesProtocolPart)
     robot_workspace = ProtocolPartDescriptor(RobotWorkspaceProtocolPart)
 
     robot_discovering = ProtocolPartDescriptor(DiscoveringProtocolPart)

Original file line number	Diff line number	Diff line change
`@@ -1724,7 +1724,9 @@ def find_keyword(`
`1724`	`1724`	`if result is None:`
`1725`	`1725`	`self.diagnostics.append(`
`1726`	`1726`	`DiagnosticsEntry(`
`1727`		`- f"No keyword with name {repr(name)} found.", DiagnosticSeverity.ERROR, "KeywordError"`
	`1727`	`+ f"No keyword with name {repr(name)} found.",`
	`1728`	`+ DiagnosticSeverity.ERROR,`
	`1729`	`+ "KeywordNotFoundError",`
`1728`	`1730`	`)`
`1729`	`1731`	`)`
`1730`	`1732`	`except KeywordError as e:`