Add Show in Memory Inspector entry to Watch view context menu

VS Code 1.103 introduced the debug/watch/context menu extension point (microsoft/vscode#237751), which lets extensions contribute actions to the Watch view context menu. The Watch view passes the IExpression instance directly as the command argument instead of the wrapped {sessionId, container, variable} shape used by the Variables view, so a separate type guard is required.

- Add WatchView.IWatchItemContext type and isWatchItemContext guard in src/common/external-views.ts.

- Teach the show-variable and go-to-value command handlers in memory-webview-main.ts to accept the Watch view argument shape, resolving the memory reference from memoryReference (always populated when canViewMemory is true) with a fallback to getAddressOfVariable(evaluateName ?? name).

- Mirror the debug/variables/context menu entries under debug/watch/context in package.json so show-variable, go-to-value and store-file are offered on watch items when the debug adapter supports reading memory.

- Wire up mocha + ts-node + chai test infrastructure and add unit tests for isVariablesContext and isWatchItemContext covering wrapper contexts, root/child watch expressions, primitives and discrimination between the two shapes.

Fixes: #165

Signed-off-by: Morten Engelhardt Olsen <MortenEngelhardt.Olsen@microchip.com>

Author: xoriath

.mocharc.json

@@ -0,0 +1,11 @@
+{
+    "require": [
+        "ts-node/register/transpile-only"
+    ],
+    "extensions": [
+        "ts"
+    ],
+    "spec": [
+        "src/**/*.spec.ts"
+    ]
+}

package.json

@@ -28,7 +28,8 @@
     "watch": "webpack -w --mode development ",
     "lint": "eslint . --ext .ts,.tsx",
     "package": "vsce package --yarn",
-    "serve": "serve --cors -p 3333"
+    "serve": "serve --cors -p 3333",
+    "test": "mocha"
   },
   "dependencies": {
     "@vscode/codicons": "^0.0.32",
@@ -48,7 +49,9 @@
     "vscode-uri": "^3.0.8"
   },
   "devDependencies": {
+    "@types/chai": "^5.2.3",
     "@types/lodash": "^4.14.202",
+    "@types/mocha": "^10.0.10",
     "@types/node": "^20.17.22",
     "@types/react": "^18.0.26",
     "@types/react-dom": "^18.0.9",
@@ -59,16 +62,19 @@
     "@typescript-eslint/parser": "^5.45.0",
     "@vscode/debugprotocol": "^1.55.0",
     "@vscode/vsce": "^3.2.2",
+    "chai": "^5.2.3",
     "css-loader": "^6.9.0",
     "eslint": "^8.29.0",
     "eslint-plugin-deprecation": "^1.3.3",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-no-null": "^1.0.2",
     "eslint-plugin-no-unsanitized": "^4.0.2",
     "eslint-plugin-react": "^7.31.11",
+    "mocha": "^11.7.5",
     "serve": "^14.1.2",
     "style-loader": "^3.3.4",
     "ts-loader": "^9.4.2",
+    "ts-node": "^10.9.2",
     "tslint": "^6.1.3",
     "typescript": "^4.9.3",
     "webpack": "^5.75.0",
@@ -224,6 +230,20 @@
           "when": "canViewMemory && memory-inspector.canRead"
         }
       ],
+      "debug/watch/context": [
+        {
+          "command": "memory-inspector.show-variable",
+          "when": "canViewMemory && memory-inspector.canRead"
+        },
+        {
+          "command": "memory-inspector.go-to-value",
+          "when": "canViewMemory && memory-inspector.canRead && memory-inspector.variable.isPointer"
+        },
+        {
+          "command": "memory-inspector.store-file",
+          "when": "canViewMemory && memory-inspector.canRead"
+        }
+      ],
       "view/item/context": [
         {
           "command": "memory-inspector.show-variable",

src/common/debug-requests.ts

@@ -19,70 +19,126 @@ import type { DebugProtocol } from '@vscode/debugprotocol';
 import type { DebugSession } from 'vscode';
 
 export interface DebugRequestTypes {
-    'evaluate': [DebugProtocol.EvaluateArguments, DebugProtocol.EvaluateResponse['body']]
-    'initialize': [DebugProtocol.InitializeRequestArguments, DebugProtocol.InitializeResponse['body']]
-    'readMemory': [DebugProtocol.ReadMemoryArguments, DebugProtocol.ReadMemoryResponse['body']]
-    'scopes': [DebugProtocol.ScopesArguments, DebugProtocol.ScopesResponse['body']]
-    'variables': [DebugProtocol.VariablesArguments, DebugProtocol.VariablesResponse['body']]
-    'writeMemory': [DebugProtocol.WriteMemoryArguments, DebugProtocol.WriteMemoryResponse['body']]
-    'dataBreakpointInfo': [DebugProtocol.DataBreakpointInfoArguments, DebugProtocol.DataBreakpointInfoResponse['body']]
-    'setDataBreakpoints': [DebugProtocol.SetDataBreakpointsArguments, DebugProtocol.SetDataBreakpointsResponse['body']]
+  evaluate: [
+    DebugProtocol.EvaluateArguments,
+    DebugProtocol.EvaluateResponse['body'],
+  ];
+  initialize: [
+    DebugProtocol.InitializeRequestArguments,
+    DebugProtocol.InitializeResponse['body'],
+  ];
+  readMemory: [
+    DebugProtocol.ReadMemoryArguments,
+    DebugProtocol.ReadMemoryResponse['body'],
+  ];
+  scopes: [DebugProtocol.ScopesArguments, DebugProtocol.ScopesResponse['body']];
+  variables: [
+    DebugProtocol.VariablesArguments,
+    DebugProtocol.VariablesResponse['body'],
+  ];
+  writeMemory: [
+    DebugProtocol.WriteMemoryArguments,
+    DebugProtocol.WriteMemoryResponse['body'],
+  ];
+  dataBreakpointInfo: [
+    DebugProtocol.DataBreakpointInfoArguments,
+    DebugProtocol.DataBreakpointInfoResponse['body'],
+  ];
+  setDataBreakpoints: [
+    DebugProtocol.SetDataBreakpointsArguments,
+    DebugProtocol.SetDataBreakpointsResponse['body'],
+  ];
 }
 
 export interface DebugEvents {
-    'memory': DebugProtocol.MemoryEvent,
-    'continued': DebugProtocol.ContinuedEvent,
-    'stopped': DebugProtocol.StoppedEvent,
-    'output': DebugProtocol.OutputEvent
+  memory: DebugProtocol.MemoryEvent;
+  continued: DebugProtocol.ContinuedEvent;
+  stopped: DebugProtocol.StoppedEvent;
+  output: DebugProtocol.OutputEvent;
 }
 
-export type DebugRequest<C, A> = Omit<DebugProtocol.Request, 'command' | 'arguments'> & { command: C, arguments: A };
-export type DebugResponse<C, B> = Omit<DebugProtocol.Response, 'command' | 'body'> & { command: C, body: B };
+export type DebugRequest<C, A> = Omit<
+  DebugProtocol.Request,
+  'command' | 'arguments'
+> & { command: C; arguments: A };
+export type DebugResponse<C, B> = Omit<
+  DebugProtocol.Response,
+  'command' | 'body'
+> & { command: C; body: B };
 export type DebugEvent<T> = DebugProtocol.Event & { body: T };
 
-export async function sendRequest<K extends keyof DebugRequestTypes>(session: DebugSession,
-    command: K, args: DebugRequestTypes[K][0]): Promise<DebugRequestTypes[K][1]> {
-    return session.customRequest(command, args);
+export async function sendRequest<K extends keyof DebugRequestTypes>(
+  session: DebugSession,
+  command: K,
+  args: DebugRequestTypes[K][0],
+): Promise<DebugRequestTypes[K][1]> {
+  return session.customRequest(command, args);
 }
 
-export function isDebugVariable(variable: DebugProtocol.Variable | unknown): variable is DebugProtocol.Variable {
-    const assumed = variable ? variable as DebugProtocol.Variable : undefined;
-    return typeof assumed?.name === 'string' && typeof assumed?.value === 'string';
+export function isDebugVariable(
+  variable: DebugProtocol.Variable | unknown,
+): variable is DebugProtocol.Variable {
+  const assumed = variable ? (variable as DebugProtocol.Variable) : undefined;
+  return (
+    typeof assumed?.name === 'string' && typeof assumed?.value === 'string'
+  );
 }
 
-export function isDebugScope(scope: DebugProtocol.Scope | unknown): scope is DebugProtocol.Scope {
-    const assumed = scope ? scope as DebugProtocol.Scope : undefined;
-    return typeof assumed?.name === 'string' && typeof assumed?.variablesReference === 'number';
+export function isDebugScope(
+  scope: DebugProtocol.Scope | unknown,
+): scope is DebugProtocol.Scope {
+  const assumed = scope ? (scope as DebugProtocol.Scope) : undefined;
+  return (
+    typeof assumed?.name === 'string' &&
+    typeof assumed?.variablesReference === 'number'
+  );
 }
 
-export function isDebugEvaluateArguments(args: DebugProtocol.EvaluateArguments | unknown): args is DebugProtocol.EvaluateArguments {
-    const assumed = args ? args as DebugProtocol.EvaluateArguments : undefined;
-    return typeof assumed?.expression === 'string';
+export function isDebugEvaluateArguments(
+  args: DebugProtocol.EvaluateArguments | unknown,
+): args is DebugProtocol.EvaluateArguments {
+  const assumed = args ? (args as DebugProtocol.EvaluateArguments) : undefined;
+  return typeof assumed?.expression === 'string';
 }
 
-export function isDebugRequest<K extends keyof DebugRequestTypes>(command: K, message: unknown): message is DebugRequest<K, DebugRequestTypes[K][0]> {
-    return isDebugRequestType(message) && message.command === command;
+export function isDebugRequest<K extends keyof DebugRequestTypes>(
+  command: K,
+  message: unknown,
+): message is DebugRequest<K, DebugRequestTypes[K][0]> {
+  return isDebugRequestType(message) && message.command === command;
 }
 
-export function isDebugResponse<K extends keyof DebugRequestTypes>(command: K, message: unknown): message is DebugResponse<K, DebugRequestTypes[K][1]> {
-    return isDebugResponseType(message) && message.command === command;
+export function isDebugResponse<K extends keyof DebugRequestTypes>(
+  command: K,
+  message: unknown,
+): message is DebugResponse<K, DebugRequestTypes[K][1]> {
+  return isDebugResponseType(message) && message.command === command;
 }
 
-export function isDebugEvent<K extends keyof DebugEvents>(event: K, message: unknown): message is DebugEvents[K] {
-    return isDebugEventType(message) && message.event === event;
+export function isDebugEvent<K extends keyof DebugEvents>(
+  event: K,
+  message: unknown,
+): message is DebugEvents[K] {
+  return isDebugEventType(message) && message.event === event;
 }
 
-export function isDebugRequestType(message: unknown): message is DebugProtocol.Request {
-    const assumed = message ? message as DebugProtocol.Request : undefined;
-    return !!assumed && assumed.type === 'request';
+export function isDebugRequestType(
+  message: unknown,
+): message is DebugProtocol.Request {
+  const assumed = message ? (message as DebugProtocol.Request) : undefined;
+  return !!assumed && assumed.type === 'request';
 }
 
-export function isDebugResponseType(message: unknown): message is DebugProtocol.Response {
-    const assumed = message ? message as DebugProtocol.Response : undefined;
-    return !!assumed && assumed.type === 'response';
+export function isDebugResponseType(
+  message: unknown,
+): message is DebugProtocol.Response {
+  const assumed = message ? (message as DebugProtocol.Response) : undefined;
+  return !!assumed && assumed.type === 'response';
 }
 
-export function isDebugEventType(message: unknown): message is DebugProtocol.Event {
-    const assumed = message ? message as DebugProtocol.Event : undefined;
-    return !!assumed && assumed.type === 'event';
+export function isDebugEventType(
+  message: unknown,
+): message is DebugProtocol.Event {
+  const assumed = message ? (message as DebugProtocol.Event) : undefined;
+  return !!assumed && assumed.type === 'event';
 }

src/common/external-views.spec.ts

@@ -0,0 +1,138 @@
+/********************************************************************************
+ * Copyright (C) 2026 Microchip Technology Inc. and its subsidiaries and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { expect } from 'chai';
+import { isVariablesContext, isWatchItemContext, VariablesView, WatchView } from './external-views';
+
+describe('external-views', () => {
+    describe('isVariablesContext', () => {
+        it('accepts a fully-formed Variables view context with a Scope container', () => {
+            const ctx: VariablesView.IVariablesContext = {
+                sessionId: 'session-1',
+                container: { name: 'Locals', variablesReference: 1000, expensive: false },
+                variable: { name: 'foo', value: '42', variablesReference: 0 }
+            };
+            expect(isVariablesContext(ctx)).to.equal(true);
+        });
+
+        it('accepts a Variables view context with a Variable container (nested variable)', () => {
+            const ctx: VariablesView.IVariablesContext = {
+                sessionId: 'session-1',
+                container: { name: 'parent', value: '{...}', variablesReference: 2000 },
+                variable: { name: 'child', value: '7', variablesReference: 0 }
+            };
+            expect(isVariablesContext(ctx)).to.equal(true);
+        });
+
+        it('accepts a Variables view context with an EvaluateArguments container', () => {
+            const ctx: VariablesView.IVariablesContext = {
+                sessionId: 'session-1',
+                container: { expression: 'someExpr' },
+                variable: { name: 'child', value: '7', variablesReference: 0 }
+            };
+            expect(isVariablesContext(ctx)).to.equal(true);
+        });
+
+        it('rejects undefined / null / primitive values', () => {
+            expect(isVariablesContext(undefined)).to.equal(false);
+            // eslint-disable-next-line no-null/no-null
+            expect(isVariablesContext(null as unknown)).to.equal(false);
+            expect(isVariablesContext(42)).to.equal(false);
+            expect(isVariablesContext('string')).to.equal(false);
+        });
+
+        it('rejects an object missing the variable field', () => {
+            expect(isVariablesContext({ sessionId: 's', container: { expression: 'e' } })).to.equal(false);
+        });
+
+        it('rejects an object with an unexpected container shape', () => {
+            expect(isVariablesContext({
+                sessionId: 's',
+                container: { unexpected: true },
+                variable: { name: 'x', value: '1' }
+            })).to.equal(false);
+        });
+
+        it('rejects a watch expression shape that lacks container/variable', () => {
+            const watchLike = { name: 'g_counter', value: '42', memoryReference: '0xdeadbeef' };
+            expect(isVariablesContext(watchLike)).to.equal(false);
+        });
+    });
+
+    describe('isWatchItemContext', () => {
+        it('accepts a root watch expression with memoryReference set', () => {
+            const watch: WatchView.IWatchItemContext = {
+                name: 'g_counter',
+                value: '42',
+                type: 'int',
+                memoryReference: '0xdeadbeef',
+                evaluateName: 'g_counter'
+            };
+            expect(isWatchItemContext(watch)).to.equal(true);
+        });
+
+        it('accepts a child watch variable with only name/value', () => {
+            const child = { name: 'field', value: '0' };
+            expect(isWatchItemContext(child)).to.equal(true);
+        });
+
+        it('accepts a minimal watch item with just a name', () => {
+            expect(isWatchItemContext({ name: 'expr' })).to.equal(true);
+        });
+
+        it('rejects a Variables view wrapper context (handled by isVariablesContext instead)', () => {
+            const wrapped: VariablesView.IVariablesContext = {
+                sessionId: 'session-1',
+                container: { name: 'Locals', variablesReference: 1000, expensive: false },
+                variable: { name: 'foo', value: '42', variablesReference: 0 }
+            };
+            expect(isWatchItemContext(wrapped)).to.equal(false);
+        });
+
+        it('rejects undefined / null / primitive values', () => {
+            expect(isWatchItemContext(undefined)).to.equal(false);
+            // eslint-disable-next-line no-null/no-null
+            expect(isWatchItemContext(null as unknown)).to.equal(false);
+            expect(isWatchItemContext(42)).to.equal(false);
+            expect(isWatchItemContext('string')).to.equal(false);
+            expect(isWatchItemContext(true)).to.equal(false);
+        });
+
+        it('rejects an empty object', () => {
+            expect(isWatchItemContext({})).to.equal(false);
+        });
+
+        it('rejects an object whose name is not a string', () => {
+            expect(isWatchItemContext({ name: 42 })).to.equal(false);
+            expect(isWatchItemContext({ name: undefined })).to.equal(false);
+        });
+
+        it('discriminates: variables wrappers match isVariablesContext only, watch items match isWatchItemContext only', () => {
+            const wrapped: VariablesView.IVariablesContext = {
+                sessionId: 'session-1',
+                container: { expression: 'x' },
+                variable: { name: 'foo', value: '42', variablesReference: 0 }
+            };
+            const watchItem: WatchView.IWatchItemContext = { name: 'expr', memoryReference: '0x1' };
+
+            expect(isVariablesContext(wrapped)).to.equal(true);
+            expect(isWatchItemContext(wrapped)).to.equal(false);
+
+            expect(isWatchItemContext(watchItem)).to.equal(true);
+            expect(isVariablesContext(watchItem)).to.equal(false);
+        });
+    });
+});