feat(langserver): code action - extract keyword

closes #158

Author: d-biehl

packages/language_server/src/robotcode/language_server/common/parts/code_action.py

@@ -100,7 +100,7 @@ async def _text_document_code_action(
 
         return results
 
-    @rpc_method(name="textDocument/codeAction/resolve", param_type=CodeAction)
+    @rpc_method(name="codeAction/resolve", param_type=CodeAction)
     @threaded()
     async def _text_document_code_action_resolve(
         self,

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -36,9 +36,11 @@
 from robotcode.language_server.robotframework.utils.version import get_robot_version
 
 from .entities import (
+    ArgumentDefinition,
     CommandLineVariableDefinition,
     EnvironmentVariableDefinition,
     LibraryEntry,
+    LocalVariableDefinition,
     ResourceEntry,
     VariableDefinition,
     VariableDefinitionType,
@@ -57,6 +59,7 @@ class AnalyzerResult:
     diagnostics: List[Diagnostic]
     keyword_references: Dict[KeywordDoc, Set[Location]]
     variable_references: Dict[VariableDefinition, Set[Location]]
+    local_variable_assignments: Dict[VariableDefinition, Set[Range]]
     namespace_references: Dict[LibraryEntry, Set[Location]]
 
 
@@ -86,6 +89,7 @@ def __init__(
         self._diagnostics: List[Diagnostic] = []
         self._keyword_references: Dict[KeywordDoc, Set[Location]] = defaultdict(set)
         self._variable_references: Dict[VariableDefinition, Set[Location]] = defaultdict(set)
+        self._local_variable_assignments: Dict[VariableDefinition, Set[Range]] = defaultdict(set)
         self._namespace_references: Dict[LibraryEntry, Set[Location]] = defaultdict(set)
 
     async def run(self) -> AnalyzerResult:
@@ -95,7 +99,11 @@ async def run(self) -> AnalyzerResult:
         await self.visit(self.model)
 
         return AnalyzerResult(
-            self._diagnostics, self._keyword_references, self._variable_references, self._namespace_references
+            self._diagnostics,
+            self._keyword_references,
+            self._variable_references,
+            self._local_variable_assignments,
+            self._namespace_references,
         )
 
     def yield_argument_name_and_rest(self, node: ast.AST, token: Token) -> Iterator[Token]:
@@ -243,9 +251,7 @@ async def visit(self, node: ast.AST) -> None:
                                     if isinstance(var, EnvironmentVariableDefinition):
                                         var_token.value, _, _ = var_token.value.partition("=")
 
-                                        var_range = range_from_token(var_token)
-                                    else:
-                                        var_range = range_from_token(var_token)
+                                    var_range = range_from_token(var_token)
 
                                     suite_var = None
                                     if isinstance(var, CommandLineVariableDefinition):
@@ -267,6 +273,10 @@ async def visit(self, node: ast.AST) -> None:
                                             self._variable_references[suite_var].add(
                                                 Location(self.namespace.document.document_uri, var_range)
                                             )
+                                        if token1.type in [RobotToken.ASSIGN] and isinstance(
+                                            var, (LocalVariableDefinition, ArgumentDefinition)
+                                        ):
+                                            self._local_variable_assignments[var].add(var_range)
 
                                     elif var not in self._variable_references and token1.type in [
                                         RobotToken.ASSIGN,

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -558,6 +558,7 @@ def __init__(
         self._diagnostics: List[Diagnostic] = []
         self._keyword_references: Dict[KeywordDoc, Set[Location]] = {}
         self._variable_references: Dict[VariableDefinition, Set[Location]] = {}
+        self._local_variable_assignments: Dict[VariableDefinition, Set[Range]] = {}
         self._namespace_references: Dict[LibraryEntry, Set[Location]] = {}
 
         self._imported_keywords: Optional[List[KeywordDoc]] = None
@@ -711,6 +712,13 @@ async def get_variable_references(self) -> Dict[VariableDefinition, Set[Location
 
         return self._variable_references
 
+    async def get_local_variable_assignments(self) -> Dict[VariableDefinition, Set[Range]]:
+        await self.ensure_initialized()
+
+        await self._analyze()
+
+        return self._local_variable_assignments
+
     async def get_namespace_references(self) -> Dict[LibraryEntry, Set[Location]]:
         await self.ensure_initialized()
 
@@ -1577,6 +1585,7 @@ async def _analyze(self) -> None:
                     self._diagnostics += result.diagnostics
                     self._keyword_references = result.keyword_references
                     self._variable_references = result.variable_references
+                    self._local_variable_assignments = result.local_variable_assignments
                     self._namespace_references = result.namespace_references
 
                     lib_doc = await self.get_library_doc()

packages/language_server/src/robotcode/language_server/robotframework/parts/code_action_helper_mixin.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import ast
+from typing import List, Optional, Tuple
+
+from robotcode.core.lsp.types import (
+    Position,
+    Range,
+)
+from robotcode.language_server.common.text_document import TextDocument
+from robotcode.language_server.robotframework.diagnostics.namespace import Namespace
+from robotcode.language_server.robotframework.utils.ast_utils import (
+    range_from_node,
+)
+from robotcode.language_server.robotframework.utils.async_ast import Visitor
+
+
+class FindSectionsVisitor(Visitor):
+    def __init__(self) -> None:
+        self.keyword_sections: List[ast.AST] = []
+        self.variable_sections: List[ast.AST] = []
+        self.setting_sections: List[ast.AST] = []
+        self.testcase_sections: List[ast.AST] = []
+        self.sections: List[ast.AST] = []
+
+    def visit_KeywordSection(self, node: ast.AST) -> None:  # noqa: N802
+        self.keyword_sections.append(node)
+        self.sections.append(node)
+
+    def visit_VariableSection(self, node: ast.AST) -> None:  # noqa: N802
+        self.variable_sections.append(node)
+        self.sections.append(node)
+
+    def visit_SettingSection(self, node: ast.AST) -> None:  # noqa: N802
+        self.setting_sections.append(node)
+        self.sections.append(node)
+
+    def visit_TestCaseSection(self, node: ast.AST) -> None:  # noqa: N802
+        self.testcase_sections.append(node)
+        self.sections.append(node)
+
+    def visit_CommentSection(self, node: ast.AST) -> None:  # noqa: N802
+        self.sections.append(node)
+
+
+def find_keyword_sections(node: ast.AST) -> Optional[List[ast.AST]]:
+    visitor = FindSectionsVisitor()
+    visitor.visit(node)
+    return visitor.keyword_sections if visitor.keyword_sections else None
+
+
+class CodeActionHelperMixin:
+    async def create_insert_keyword_workspace_edit(
+        self, document: TextDocument, model: ast.AST, namespace: Namespace, insert_text: str
+    ) -> Tuple[str, Range]:
+        keyword_sections = find_keyword_sections(model)
+        keyword_section = keyword_sections[-1] if keyword_sections else None
+
+        lines = document.get_lines()
+
+        if keyword_section is not None:
+            node_range = range_from_node(keyword_section, skip_non_data=True, allow_comments=True)
+            insert_pos = Position(node_range.end.line + 1, 0)
+            insert_range = Range(insert_pos, insert_pos)
+            insert_text = f"\n\n{insert_text}"
+        else:
+            if namespace.languages is None or not namespace.languages.languages:
+                keywords_text = "Keywords"
+            else:
+                keywords_text = namespace.languages.languages[-1].keywords_header
+
+            insert_text = f"\n\n*** {keywords_text} ***\n{insert_text}"
+
+            end_line = len(lines) - 1
+            while end_line >= 0 and not lines[end_line].strip():
+                end_line -= 1
+            doc_pos = Position(end_line + 1, 0)
+
+            insert_range = Range(doc_pos, doc_pos)
+
+        if insert_range.start.line >= len(lines) and lines[-1].strip():
+            doc_pos = Position(len(lines) - 1, len(lines[-1]))
+            insert_range = Range(doc_pos, doc_pos)
+            insert_text = "\n" + insert_text
+
+        if insert_range.start.line <= len(lines) and lines[insert_range.start.line].startswith("*"):
+            insert_text = insert_text + "\n\n"
+        if (
+            insert_range.start.line + 1 < len(lines)
+            and not lines[insert_range.start.line].strip()
+            and lines[insert_range.start.line + 1].startswith("*")
+        ):
+            insert_text = insert_text + "\n"
+        return insert_text, insert_range

packages/language_server/src/robotcode/language_server/robotframework/parts/code_action_quick_fixes.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import ast
 from collections import defaultdict
 from string import Template
 from typing import TYPE_CHECKING, Any, List, Optional, Union, cast
@@ -35,8 +34,8 @@
     range_from_node,
     range_from_token,
 )
-from robotcode.language_server.robotframework.utils.async_ast import Visitor
 
+from .code_action_helper_mixin import CodeActionHelperMixin, FindSectionsVisitor
 from .model_helper import ModelHelperMixin
 from .protocol_part import RobotLanguageServerProtocolPart
 
@@ -62,41 +61,7 @@
 )
 
 
-class FindSectionsVisitor(Visitor):
-    def __init__(self) -> None:
-        self.keyword_sections: List[ast.AST] = []
-        self.variable_sections: List[ast.AST] = []
-        self.setting_sections: List[ast.AST] = []
-        self.testcase_sections: List[ast.AST] = []
-        self.sections: List[ast.AST] = []
-
-    def visit_KeywordSection(self, node: ast.AST) -> None:  # noqa: N802
-        self.keyword_sections.append(node)
-        self.sections.append(node)
-
-    def visit_VariableSection(self, node: ast.AST) -> None:  # noqa: N802
-        self.variable_sections.append(node)
-        self.sections.append(node)
-
-    def visit_SettingSection(self, node: ast.AST) -> None:  # noqa: N802
-        self.setting_sections.append(node)
-        self.sections.append(node)
-
-    def visit_TestCaseSection(self, node: ast.AST) -> None:  # noqa: N802
-        self.testcase_sections.append(node)
-        self.sections.append(node)
-
-    def visit_CommentSection(self, node: ast.AST) -> None:  # noqa: N802
-        self.sections.append(node)
-
-
-def find_keyword_sections(node: ast.AST) -> Optional[List[ast.AST]]:
-    visitor = FindSectionsVisitor()
-    visitor.visit(node)
-    return visitor.keyword_sections if visitor.keyword_sections else None
-
-
-class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin):
+class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin, CodeActionHelperMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: RobotLanguageServerProtocol) -> None:
@@ -261,44 +226,9 @@ async def _apply_create_keyword(self, document: TextDocument, insert_text: str)
         model = await self.parent.documents_cache.get_model(document, False)
         namespace = await self.parent.documents_cache.get_namespace(document)
 
-        keyword_sections = find_keyword_sections(model)
-        keyword_section = keyword_sections[-1] if keyword_sections else None
-
-        lines = document.get_lines()
-
-        if keyword_section is not None:
-            node_range = range_from_node(keyword_section, skip_non_data=True, allow_comments=True)
-            insert_pos = Position(node_range.end.line + 1, 0)
-            insert_range = Range(insert_pos, insert_pos)
-            insert_text = f"\n\n{insert_text}"
-        else:
-            if namespace.languages is None or not namespace.languages.languages:
-                keywords_text = "Keywords"
-            else:
-                keywords_text = namespace.languages.languages[-1].keywords_header
-
-            insert_text = f"\n\n*** {keywords_text} ***\n{insert_text}"
-
-            end_line = len(lines) - 1
-            while end_line >= 0 and not lines[end_line].strip():
-                end_line -= 1
-            doc_pos = Position(end_line + 1, 0)
-
-            insert_range = Range(doc_pos, doc_pos)
-
-        if insert_range.start.line >= len(lines) and lines[-1].strip():
-            doc_pos = Position(len(lines) - 1, len(lines[-1]))
-            insert_range = Range(doc_pos, doc_pos)
-            insert_text = "\n" + insert_text
-
-        if insert_range.start.line <= len(lines) and lines[insert_range.start.line].startswith("*"):
-            insert_text = insert_text + "\n\n"
-        if (
-            insert_range.start.line + 1 <= len(lines)
-            and not lines[insert_range.start.line].strip()
-            and lines[insert_range.start.line + 1].startswith("*")
-        ):
-            insert_text = insert_text + "\n"
+        insert_text, insert_range = await self.create_insert_keyword_workspace_edit(
+            document, model, namespace, insert_text
+        )
 
         we = WorkspaceEdit(
             document_changes=[