implement set variable in debugger

Author: d-biehl

robotcode/debug_adapter/launcher/debugger.py

@@ -47,6 +47,14 @@ class EvaluateResult(NamedTuple):
     memory_reference: Optional[str] = None
 
 
+class SetVariableResult(NamedTuple):
+    value: str
+    type: Optional[str]
+    variables_reference: Optional[int] = None
+    named_variables: Optional[int] = None
+    indexed_variables: Optional[int] = None
+
+
 class State(Enum):
     Stopped = 0
     Running = 1
@@ -668,24 +676,19 @@ def get_variables(
         if entry is not None:
             context = entry.context()
             if context is not None:
-
                 if entry.global_id() == variables_reference:
                     result += [
                         Variable(name=k, value=repr(v), type=repr(type(v)))
                         for k, v in context.variables._global.as_dict().items()
                     ]
                 elif entry.suite_id() == variables_reference:
-                    # current_index = context.variables._scopes.index(context.variables._suite)
-                    # globals = context.variables._scopes[max(current_index - 1, 0)].as_dict()
                     globals = context.variables._global.as_dict()
                     result += [
                         Variable(name=k, value=repr(v), type=repr(type(v)))
                         for k, v in context.variables._suite.as_dict().items()
                         if k not in globals or globals[k] != v
                     ]
                 elif entry.test_id() == variables_reference:
-                    # current_index = context.variables._scopes.index(context.variables._test)
-                    # globals = context.variables._scopes[max(current_index - 1, 0)].as_dict()
                     globals = context.variables._suite.as_dict()
                     result += [
                         Variable(name=k, value=repr(v), type=repr(type(v)))
@@ -703,7 +706,7 @@ def get_variables(
 
         return result
 
-    VARS_RE = re.compile(r"^[$@&%]\{.*\}$")
+    IS_VARIABLE_RE = re.compile(r"^[$@&%]\{.*\}$")
 
     def evaluate(
         self,
@@ -734,7 +737,7 @@ def evaluate(
                 vars = (
                     evaluate_context.variables.current if frame_id is not None else evaluate_context.variables._global
                 )
-                if self.VARS_RE.match(expression.strip()):
+                if self.IS_VARIABLE_RE.match(expression.strip()):
                     result = vars.replace_string(expression)
                 else:
                     result = evaluate_expression(vars.replace_string(expression), vars.store)
@@ -748,3 +751,32 @@ def evaluate(
                 result = e
 
         return EvaluateResult(repr(result), repr(type(result)))
+
+    def set_variable(
+        self, variables_reference: int, name: str, value: str, format: Optional[ValueFormat] = None
+    ) -> SetVariableResult:
+        from robot.variables.evaluation import evaluate_expression
+
+        entry = next(
+            (
+                v
+                for v in self.stack_frames
+                if variables_reference in [v.global_id(), v.local_id(), v.suite_id(), v.test_id()]
+            ),
+            None,
+        )
+
+        if entry is not None:
+            context = entry.context()
+            if context is not None:
+                variables = context.variables.current
+
+                if (name[2:-1] if self.IS_VARIABLE_RE.match(name) else name) not in variables:
+                    raise NameError(f"Variable '{name}' not found.")
+
+                evaluated_value = evaluate_expression(variables.replace_string(value), variables.store)
+                variables[name] = evaluated_value
+
+                return SetVariableResult(repr(evaluated_value), repr(type(value)))
+
+        raise ReferenceError("Invalid variable reference.")

robotcode/debug_adapter/launcher/server.py

@@ -24,6 +24,8 @@
     ScopesResponseBody,
     SetBreakpointsArguments,
     SetBreakpointsResponseBody,
+    SetVariableArguments,
+    SetVariableResponseBody,
     StackTraceArguments,
     StackTraceResponseBody,
     StepInArguments,
@@ -217,7 +219,6 @@ async def _evaluate(
         frame_id: Optional[int] = None,
         context: Union[EvaluateArgumentContext, str, None] = None,
         format: Optional[ValueFormat] = None,
-        **kwargs: Any,
     ) -> EvaluateResponseBody:
         result = Debugger.instance().evaluate(expression, frame_id, context, format)
         return EvaluateResponseBody(
@@ -230,6 +231,24 @@ async def _evaluate(
             memory_reference=result.memory_reference,
         )
 
+    @rpc_method(name="setVariable", param_type=SetVariableArguments)
+    async def _set_variable(
+        self,
+        arguments: SetVariableArguments,
+        variables_reference: int,
+        name: str,
+        value: str,
+        format: Optional[ValueFormat] = None,
+    ) -> SetVariableResponseBody:
+        result = Debugger.instance().set_variable(variables_reference, name, value, format)
+        return SetVariableResponseBody(
+            value=result.value,
+            type=result.type,
+            variables_reference=result.variables_reference,
+            named_variables=result.named_variables,
+            indexed_variables=result.indexed_variables,
+        )
+
 
 class LaucherServer(JsonRPCServer[LauncherServerProtocol]):
     def __init__(

robotcode/debug_adapter/server.py

@@ -85,7 +85,11 @@ async def _initialize(self, arguments: InitializeRequestArguments) -> Capabiliti
             supports_evaluate_for_hovers=True,
             # supports_loaded_sources_request=True,
             supports_terminate_request=True,
-            # supports_data_breakpoints=True
+            # supports_data_breakpoints=True,
+            supports_log_points=True,
+            supports_set_expression=True,
+            supports_set_variable=True,
+            supports_value_formatting_options=True,
         )
 
     @rpc_method(name="launch", param_type=LaunchRequestArguments)

robotcode/debug_adapter/types.py

@@ -708,3 +708,27 @@ class EvaluateResponseBody(Model):
 
 class EvaluateResponse(Response):
     body: VariablesResponseBody
+
+
+class SetVariableArguments(Model):
+    variables_reference: int
+    name: str
+    value: str
+    format: Optional[ValueFormat] = None
+
+
+class SetVariableRequest(Request):
+    command: str = Field("setVariable", const=True)
+    arguments: SetVariableArguments
+
+
+class SetVariableResponseBody(Model):
+    value: str
+    type: Optional[str]
+    variables_reference: Optional[int] = None
+    named_variables: Optional[int] = None
+    indexed_variables: Optional[int] = None
+
+
+class SetVariableResponse(Response):
+    body: SetVariableResponseBody