refactor(langserver): simplify variable renaming

Author: d-biehl

packages/core/src/robotcode/core/text_document.py

@@ -216,6 +216,70 @@ def get_lines(self) -> List[str]:
 
             return self._lines
 
+    def get_text(self, r: Range) -> str:
+        lines = self.get_lines()
+
+        start_pos = r.start
+        end_pos = r.end
+
+        # Validate range
+        if start_pos.line < 0 or start_pos.character < 0:
+            raise InvalidRangeError(f"Invalid start position: {start_pos}")
+        if end_pos.line < 0 or end_pos.character < 0:
+            raise InvalidRangeError(f"Invalid end position: {end_pos}")
+        if start_pos > end_pos:
+            raise InvalidRangeError(f"Start position is greater than end position: {r}")
+
+        # Handle case where range is beyond document
+        if start_pos.line >= len(lines):
+            return ""
+
+        # Single line case
+        if start_pos.line == end_pos.line:
+            if start_pos.line < len(lines):
+                line = lines[start_pos.line]
+                # Handle newline character at end of line
+                if line.endswith(("\n", "\r\n")):
+                    line_content = line.rstrip("\r\n")
+                    if end_pos.character > len(line_content):
+                        # Include the newline character(s)
+                        return line[start_pos.character :]
+
+                    return line_content[start_pos.character : end_pos.character]
+
+                return line[start_pos.character : end_pos.character]
+            return ""
+
+        # Multi-line case
+        result_lines = []
+
+        # First line
+        if start_pos.line < len(lines):
+            first_line = lines[start_pos.line]
+            if first_line.endswith(("\n", "\r\n")):
+                result_lines.append(first_line[start_pos.character :])
+            else:
+                result_lines.append(first_line[start_pos.character :] + "\n")
+
+        # Middle lines
+        for line_idx in range(start_pos.line + 1, min(end_pos.line, len(lines))):
+            result_lines.append(lines[line_idx])
+
+        # Last line
+        if end_pos.line < len(lines):
+            last_line = lines[end_pos.line]
+            if last_line.endswith(("\n", "\r\n")):
+                line_content = last_line.rstrip("\r\n")
+                if end_pos.character > len(line_content):
+                    # Include the newline character(s)
+                    result_lines.append(last_line)
+                else:
+                    result_lines.append(line_content[: end_pos.character])
+            else:
+                result_lines.append(last_line[: end_pos.character])
+
+        return "".join(result_lines)
+
     @event
     def cache_invalidate(sender) -> None: ...
 

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

@@ -46,12 +46,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
             )
 
     @event
-    def collect(
-        sender,
-        document: TextDocument,
-        position: Position,
-        new_name: str,
-    ) -> Optional[WorkspaceEdit]: ...
+    def collect(sender, document: TextDocument, position: Position, new_name: str) -> Optional[WorkspaceEdit]: ...
 
     @event
     def collect_prepare(sender, document: TextDocument, position: Position) -> Optional[PrepareRenameResult]: ...
@@ -81,6 +76,9 @@ def _text_document_rename(
             check_current_task_canceled()
 
             if isinstance(result, BaseException):
+                if isinstance(result, CantRenameError):
+                    raise JsonRPCErrorException(ErrorCodes.INVALID_PARAMS, str(result))
+
                 if not isinstance(result, CancelledError):
                     self._logger.exception(result, exc_info=result)
             else:

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

@@ -15,6 +15,7 @@
 from robot.parsing.lexer.tokens import Token
 from robot.parsing.model.statements import Statement
 
+from robotcode.core.concurrent import check_current_task_canceled
 from robotcode.core.language import language_id
 from robotcode.core.lsp.types import (
     AnnotatedTextEdit,
@@ -25,6 +26,7 @@
     Position,
     PrepareRenameResult,
     PrepareRenameResultType1,
+    Range,
     RenameFile,
     TextDocumentEdit,
     WorkspaceEdit,
@@ -142,7 +144,7 @@ def _prepare_rename_default(
     ) -> Optional[PrepareRenameResult]:
         result = self._find_default(nodes, document, position)
         if result is not None:
-            var, token = result
+            var, found_range = result
 
             if var.type == VariableDefinitionType.BUILTIN_VARIABLE:
                 self.parent.window.show_message("You cannot rename a builtin variable, only references are renamed.")
@@ -158,13 +160,12 @@ def _prepare_rename_default(
                     "Only references are renamed and you have to rename the variable definition yourself."
                 )
             elif var.type == VariableDefinitionType.ENVIRONMENT_VARIABLE:
-                token.value, _, _ = token.value.partition("=")
                 self.parent.window.show_message(
                     "You are about to rename an environment variable. "
                     "Only references are renamed and you have to rename the variable definition yourself."
                 )
 
-            return PrepareRenameResultType1(range_from_token(token), token.value)
+            return PrepareRenameResultType1(found_range, document.get_text(found_range))
 
         return None
 
@@ -176,7 +177,11 @@ def _rename_default(
         new_name: str,
     ) -> Optional[WorkspaceEdit]:
         result = self._find_default(nodes, document, position)
-
+        if "  " in new_name or "\t" in new_name:
+            raise CantRenameError(
+                "Variable names cannot contain more then one spaces or tabs. "
+                "Please use only one space or underscores instead.",
+            )
         if result is not None:
             var, _ = result
 
@@ -209,49 +214,29 @@ def _rename_default(
 
     def _find_default(
         self, nodes: List[ast.AST], document: TextDocument, position: Position
-    ) -> Optional[Tuple[VariableDefinition, Token]]:
-        from robot.parsing.lexer.tokens import Token as RobotToken
-
+    ) -> Optional[Tuple[VariableDefinition, Range]]:
         namespace = self.parent.documents_cache.get_namespace(document)
 
-        if not nodes:
-            return None
-
-        node = nodes[-1]
-
-        if not isinstance(node, Statement):
-            return None
-
-        tokens = get_tokens_at_position(node, position)
-
-        token_and_var: Optional[Tuple[VariableDefinition, Token]] = None
-
-        for token in tokens:
-            token_and_var = next(
-                (
-                    (var, var_token)
-                    for var_token, var in self.iter_variables_from_token(token, namespace, nodes, position)
-                    if position in range_from_token(var_token)
-                ),
-                None,
-            )
-
-        if (
-            token_and_var is None
-            and isinstance(node, self.get_expression_statement_types())
-            and (token := node.get_token(RobotToken.ARGUMENT)) is not None
-            and position in range_from_token(token)
-        ):
-            token_and_var = next(
-                (
-                    (var, var_token)
-                    for var_token, var in self.iter_expression_variables_from_token(token, namespace, nodes, position)
-                    if position in range_from_token(var_token)
-                ),
-                None,
-            )
+        all_variable_refs = namespace.get_variable_references()
+        if all_variable_refs:
+            for variable, var_refs in all_variable_refs.items():
+                check_current_task_canceled()
+
+                found_range = (
+                    variable.name_range
+                    if variable.source == namespace.source and position.is_in_range(variable.name_range, False)
+                    else cast(
+                        Optional[Range],
+                        next(
+                            (r.range for r in var_refs if position.is_in_range(r.range)),
+                            None,
+                        ),
+                    )
+                )
 
-        return token_and_var
+                if found_range is not None:
+                    return variable, found_range
+        return None
 
     def _prepare_rename_keyword(self, result: Optional[Tuple[KeywordDoc, Token]]) -> Optional[PrepareRenameResult]:
         if result is not None:

packages/robot/src/robotcode/robot/diagnostics/namespace_analyzer.py

@@ -357,7 +357,7 @@ def visit_Var(self, node: Var) -> None:  # noqa: N802
 
                 var = var_type(
                     name=matcher.name,
-                    name_token=strip_variable_token(stripped_name_token),
+                    name_token=stripped_name_token,
                     line_no=stripped_name_token.lineno,
                     col_offset=stripped_name_token.col_offset,
                     end_line_no=stripped_name_token.lineno,
@@ -372,9 +372,7 @@ def visit_Var(self, node: Var) -> None:  # noqa: N802
                 else:
                     existing_var = self._variables[var.matcher]
 
-                    location = Location(
-                        self._namespace.document_uri, range_from_token(strip_variable_token(stripped_name_token))
-                    )
+                    location = Location(self._namespace.document_uri, range_from_token(stripped_name_token))
                     self._variable_references[existing_var].add(location)
                     if existing_var in self._overridden_variables:
                         self._variable_references[self._overridden_variables[existing_var]].add(location)