Add support set expression request (#535)

* Support 'setExpressionRequest'
* Send 'invalidated' event right after setting expressions or variables

Author: omarArm

src/gdb/GDBDebugSessionBase.ts

@@ -429,7 +429,7 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
         response.body.supportsHitConditionalBreakpoints = true;
         response.body.supportsLogPoints = true;
         response.body.supportsFunctionBreakpoints = true;
-        // response.body.supportsSetExpression = true;
+        response.body.supportsSetExpression = true;
         response.body.supportsDisassembleRequest = true;
         response.body.supportsReadMemoryRequest = true;
         response.body.supportsWriteMemoryRequest = true;
@@ -2214,13 +2214,54 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
             );
         }
         this.sendResponse(response);
+        this.sendEvent(new InvalidatedEvent(['variables']));
     }
 
-    // protected async setExpressionRequest(response: DebugProtocol.SetExpressionResponse,
-    //                                      args: DebugProtocol.SetExpressionArguments): Promise<void> {
-    //     logger.error('got setExpressionRequest');
-    //     this.sendResponse(response);
-    // }
+    protected async setExpressionRequest(
+        response: DebugProtocol.SetExpressionResponse,
+        args: DebugProtocol.SetExpressionArguments
+    ): Promise<void> {
+        if (!this.canRequestProceed()) {
+            this.logger.verbose(
+                'Debug adapter cannot process set variable request, skipping it.'
+            );
+            this.sendResponse(response);
+            return;
+        }
+        try {
+            const initialFrameRef = args.frameId
+                ? this.frameHandles.get(args.frameId)
+                : undefined;
+            const [gdb, frameRef, depth] =
+                await this.getFrameContext(initialFrameRef);
+            const varObj = gdb.varManager.getVar(
+                frameRef,
+                depth,
+                args.expression
+            );
+            // Not handling requests for expressions that do not have a dedicated GDB variable object for now.
+            if (!varObj) {
+                throw new Error(`Variable ${args.expression} not found`);
+            } else {
+                const assign = await mi.sendVarAssign(gdb, {
+                    varname: varObj.varname,
+                    expression: args.value,
+                    frameRef,
+                });
+                response.body = {
+                    value: assign.value,
+                };
+            }
+            this.sendResponse(response);
+            this.sendEvent(new InvalidatedEvent(['variables']));
+        } catch (err) {
+            this.sendErrorResponse(
+                response,
+                1,
+                err instanceof Error ? err.message : String(err)
+            );
+        }
+    }
 
     /**
      * Send command to backend.

src/integration-tests/evaluate.spec.ts

@@ -465,6 +465,72 @@ describe('evaluate request global variables', function () {
             });
         });
     });
+
+    it('should be able to set a simple global variable and have that change reflected in the debuggee', async function () {
+        // Read global_int using watch
+        const watchRes = await dc.evaluateRequest({
+            context: 'watch',
+            expression: 'global_int',
+            frameId: scope.frame.id,
+        });
+        expect(watchRes.body.result).to.equal('42');
+
+        // Set global_int using setExpressionRequest
+        const setRes = await dc.customRequest('setExpression', {
+            expression: 'global_int',
+            value: '100',
+            frameId: scope.frame.id,
+        });
+        expect(setRes.body.value).to.equal('100');
+
+        // Read global_int again to check updated value is returned
+        const watchResUpdated = await dc.evaluateRequest({
+            context: 'watch',
+            expression: 'global_int',
+            frameId: scope.frame.id,
+        });
+        expect(watchResUpdated.body.result).to.equal('100');
+    });
+
+    it('should be able to set a complex global variable and have that change reflected in the debuggee', async function () {
+        // Read global variable using watch
+        const watchResParent = await dc.evaluateRequest({
+            context: 'watch',
+            expression: 's1',
+            frameId: scope.frame.id,
+        });
+        const watchResChild = await dc.evaluateRequest({
+            context: 'watch',
+            expression: 's1.m',
+            frameId: scope.frame.id,
+        });
+        expect(watchResParent.body.result).to.endWith('{...}');
+        expect(watchResChild.body.result).to.equal('10');
+
+        // Set global variable using setExpressionRequest
+        const setRes = await dc.customRequest('setExpression', {
+            expression: 's1.m',
+            value: '20',
+            frameId: scope.frame.id,
+        });
+        expect(setRes.body.value).to.equal('20');
+
+        // Read global variable again to check updated value is returned
+        const watchResChildUpdated = await dc.evaluateRequest({
+            context: 'watch',
+            expression: 's1.m',
+            frameId: scope.frame.id,
+        });
+        expect(watchResChildUpdated.body.result).to.equal('20');
+
+        // Check updated value is reflected in the debuggee by evaluating an expression that uses the variable
+        const evalRes = await dc.evaluateRequest({
+            context: 'repl',
+            expression: 's1.m + 5',
+            frameId: scope.frame.id,
+        });
+        expect(evalRes.body.result).to.equal('25');
+    });
 });
 
 describe('evaluate request - watch local variable across lexical scope transition', function () {

src/integration-tests/test-programs/vars_globals.c

@@ -36,6 +36,8 @@ volatile PARENT_STRUCT s1 = {
 
 volatile PARENT_STRUCT *p_s1 = &s1;
 
+volatile int global_int = 42;
+
 int main()
 {
     // Struct with array