enabled "while running" features, silently "fail" on __Symbol_exists() (#835)

thorstendb-ARM · web-flow · commit f4711ccc848a · 2026-02-18T16:52:59.000+01:00
* enabled "while running" features
* silently "fail" on __Symbol_exists() if symbol does not exist
* added tests
diff --git a/src/views/component-viewer/component-viewer-target-access.ts b/src/views/component-viewer/component-viewer-target-access.ts
@@ -30,13 +30,9 @@ export class ComponentViewerTargetAccess {
         this._activeSession = session;
     }
 
-    public async evaluateSymbolAddress(address: string, context = 'hover'): Promise<string | undefined> {
+    public async evaluateSymbolAddress(address: string, context = 'hover', existCheck: boolean = false): Promise<string | undefined> {
         try {
             const frameId = (vscode.debug.activeStackItem as vscode.DebugStackFrame)?.frameId;
-            // if FrameId is undefined, evaluation is not possible as cdt-adapter doesn't accept it
-            if (frameId === undefined) {
-                return undefined;
-            }
             const args: DebugProtocol.EvaluateArguments = {
                 expression: `&${address}`,
                 frameId, // Currently required by CDT GDB Adapter
@@ -49,6 +45,10 @@ export class ComponentViewerTargetAccess {
             }
             return response.result.split(' ')[0]; // Return only the address part
         } catch (error: unknown) {
+            if(existCheck) {
+                // If this evaluation is just to check existence, we can treat any error as symbol not existing
+                return undefined;
+            }
             const errorMessage = (error as Error)?.message;
             componentViewerLogger.debug(`Session '${this._activeSession?.session.name}': Failed to evaluate address '${address}' - '${errorMessage}'`);
             return undefined;
@@ -76,10 +76,6 @@ export class ComponentViewerTargetAccess {
     public async evaluateSymbolName(address: string | number | bigint, context = 'hover'): Promise<string | undefined> {
         try {
             const frameId = (vscode.debug.activeStackItem as vscode.DebugStackFrame)?.frameId;
-            // if FrameId is undefined, evaluation is not possible as cdt-adapter doesn't accept it
-            if (frameId === undefined) {
-                return undefined;
-            }
             const formattedAddress = this.formatAddress(address);
             const args: DebugProtocol.EvaluateArguments = {
                 expression: `(unsigned int*)${formattedAddress}`,
@@ -103,10 +99,6 @@ export class ComponentViewerTargetAccess {
     public async evaluateSymbolContext(address: string, context = 'hover'): Promise<string | undefined> {
         try {
             const frameId = (vscode.debug.activeStackItem as vscode.DebugStackFrame)?.frameId;
-            // if FrameId is undefined, evaluation is not possible as cdt-adapter doesn't accept it
-            if (frameId === undefined) {
-                return undefined;
-            }
             const formattedAddress = this.formatAddress(address);
             // Ask GDB for file/line context of the address.
             const args: DebugProtocol.EvaluateArguments = {
@@ -130,10 +122,6 @@ export class ComponentViewerTargetAccess {
     public async evaluateSymbolSize(symbol: string, context = 'hover'): Promise<number | undefined> {
         try {
             const frameId = (vscode.debug.activeStackItem as vscode.DebugStackFrame)?.frameId;
-            // if FrameId is undefined, evaluation is not possible as cdt-adapter doesn't accept it
-            if (frameId === undefined) {
-                return undefined;
-            }
             const args: DebugProtocol.EvaluateArguments = {
                 expression: `sizeof(${symbol})`,
                 frameId,
@@ -174,10 +162,6 @@ export class ComponentViewerTargetAccess {
     public async evaluateNumberOfArrayElements(symbol: string): Promise<number | undefined> {
         try {
             const frameId = (vscode.debug.activeStackItem as vscode.DebugStackFrame)?.frameId;
-            // if FrameId is undefined, evaluation is not possible as cdt-adapter doesn't accept it
-            if (frameId === undefined) {
-                return undefined;
-            }
             const args: DebugProtocol.EvaluateArguments = {
                 expression: `sizeof(${symbol})/sizeof(${symbol}[0])`,
                 frameId, // Currently required by CDT GDB Adapter
diff --git a/src/views/component-viewer/scvd-debug-target.ts b/src/views/component-viewer/scvd-debug-target.ts
@@ -145,7 +145,7 @@ export class ScvdDebugTarget {
         });
     }
 
-    public async getSymbolInfo(symbol: string): Promise<SymbolInfo | undefined> {
+    public async getSymbolInfo(symbol: string, existCheck: boolean = false): Promise<SymbolInfo | undefined> {
         componentViewerLogger.debug(`get Symbol Info: resolving ${symbol}`);
         if (symbol === undefined) {
             componentViewerLogger.debug('get Symbol Info: no symbol provided');
@@ -157,7 +157,7 @@ export class ScvdDebugTarget {
         }
 
         const addressInfo = await this.symbolCaches.getAddressWithName(symbol, async (symbolName) => {
-            const symbolAddressStr = await this.targetAccess.evaluateSymbolAddress(symbolName);
+            const symbolAddressStr = await this.targetAccess.evaluateSymbolAddress(symbolName, 'hover', existCheck);
             if (symbolAddressStr !== undefined) {
                 const parsed = parseInt(symbolAddressStr as unknown as string, 16);
                 if (Number.isFinite(parsed)) {
@@ -242,9 +242,9 @@ export class ScvdDebugTarget {
         return this.isTargetRunning;
     }
 
-    public async findSymbolAddress(symbol: string): Promise<number | undefined> {
+    public async findSymbolAddress(symbol: string, existCheck: boolean = false): Promise<number | undefined> {
         componentViewerLogger.debug(`find Symbol Address: ${symbol}`);
-        const symbolInfo = await this.getSymbolInfo(symbol);
+        const symbolInfo = await this.getSymbolInfo(symbol, existCheck);
         return symbolInfo?.address;
     }
 
diff --git a/src/views/component-viewer/scvd-eval-interface.ts b/src/views/component-viewer/scvd-eval-interface.ts
@@ -169,12 +169,12 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr
         return trimmed && trimmed.length > 0 ? trimmed : undefined;
     }
 
-    private async findSymbolAddressNormalized(name: string | undefined): Promise<number | undefined> {
+    private async findSymbolAddressNormalized(name: string | undefined, existCheck: boolean = false): Promise<number | undefined> {
         const normalized = this.normalizeName(name);
         if (!normalized) {
             return undefined;
         }
-        return this.debugTarget.findSymbolAddress(normalized);
+        return this.debugTarget.findSymbolAddress(normalized, existCheck);
     }
 
     // ---------------- Host Interface: model + data access ----------------
@@ -347,7 +347,7 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr
     }
 
     public async __Symbol_exists(symbol: string): Promise<number | undefined> {
-        const found = await this.findSymbolAddressNormalized(symbol);
+        const found = await this.findSymbolAddressNormalized(symbol, true);
         return found !== undefined ? 1 : 0;
     }
 
diff --git a/src/views/component-viewer/test/integration/component-viewer-target-access.test.ts b/src/views/component-viewer/test/integration/component-viewer-target-access.test.ts
@@ -86,7 +86,7 @@ describe('ComponentViewerTargetAccess', () => {
             (vscode.debug.activeStackItem as unknown) = undefined;
         });
 
-        it('should return undefined when no active stack frame exists', async () => {
+        it('should evaluate symbol address when no active stack frame exists', async () => {
             (debugSession.customRequest as jest.Mock).mockResolvedValueOnce({
                 result: '0x30000000',
                 variablesReference: 0
@@ -95,8 +95,12 @@ describe('ComponentViewerTargetAccess', () => {
 
             const result = await targetAccess.evaluateSymbolAddress('globalVar');
 
-            expect(result).toBeUndefined();
-            expect(debugSession.customRequest).not.toHaveBeenCalled();
+            expect(result).toBe('0x30000000');
+            expect(debugSession.customRequest).toHaveBeenCalledWith('evaluate', {
+                expression: '&globalVar',
+                frameId: undefined,
+                context: 'hover'
+            });
         });
 
         it('should log when evaluation fails', async () => {
diff --git a/src/views/component-viewer/test/unit/component-viewer-target-access.test.ts b/src/views/component-viewer/test/unit/component-viewer-target-access.test.ts
@@ -25,15 +25,21 @@ import { debugSessionFactory } from '../../../../__test__/vscode.factory';
 import { GDBTargetDebugSession } from '../../../../debug-session';
 import { componentViewerLogger } from '../../../../logger';
 
-type DebugWithSession = {
-    activeDebugSession: vscode.DebugSession | undefined;
-    activeStackItem: vscode.DebugStackFrame | undefined;
-};
-
 function setActiveStackItem(session: vscode.DebugSession | undefined, frameId: number | undefined) {
-    (vscode.debug as unknown as DebugWithSession).activeStackItem = session
-        ? ({ session, threadId: 1, frameId } as unknown as vscode.DebugStackFrame)
-        : undefined;
+    const value = session ? { session, threadId: 1, frameId } : undefined;
+    Object.defineProperty(vscode.debug, 'activeStackItem', {
+        value,
+        configurable: true,
+        writable: true,
+    });
+}
+
+function setActiveDebugSession(session: vscode.DebugSession | undefined) {
+    Object.defineProperty(vscode.debug, 'activeDebugSession', {
+        value: session,
+        configurable: true,
+        writable: true,
+    });
 }
 
 describe('ComponentViewerTargetAccess', () => {
@@ -53,24 +59,42 @@ describe('ComponentViewerTargetAccess', () => {
         targetAccess = new ComponentViewerTargetAccess();
         targetAccess.setActiveSession(gdbTargetSession);
         setActiveStackItem(debugSession, 1);
+        setActiveDebugSession(debugSession);
     });
 
     afterEach(() => {
         setActiveStackItem(undefined, undefined);
-        (vscode.debug as unknown as DebugWithSession).activeDebugSession = undefined;
+        setActiveDebugSession(undefined);
         jest.restoreAllMocks();
     });
 
-    it('formats addresses consistently', () => {
-        const formatAddress = (targetAccess as unknown as { formatAddress: (addr: string | number | bigint) => string })
-            .formatAddress;
+    it('formats addresses consistently for symbol lookups', async () => {
+        setActiveStackItem(debugSession, 7);
+
+        const cases = [
+            { input: '', expected: '(unsigned int*)' },
+            { input: '  0x1A ', expected: '(unsigned int*)0x1A' },
+            { input: '15', expected: '(unsigned int*)0xf' },
+            { input: 16, expected: '(unsigned int*)0x10' },
+            { input: 0x20n, expected: '(unsigned int*)0x20' },
+            { input: 'not-a-number', expected: '(unsigned int*)not-a-number' },
+        ];
+
+        const expectedExpressions = cases.map(({ expected }) => expected);
+        (debugSession.customRequest as jest.Mock).mockImplementation(async (_command, args) => {
+            const expectedExpression = expectedExpressions.shift();
+            expect(args).toEqual({
+                expression: expectedExpression ?? '',
+                frameId: 7,
+                context: 'hover',
+            });
+            return { result: '0x0 <Sym>' };
+        });
 
-        expect(formatAddress('')).toBe('');
-        expect(formatAddress('  0x1A ')).toBe('0x1A');
-        expect(formatAddress('15')).toBe('0xf');
-        expect(formatAddress(16)).toBe('0x10');
-        expect(formatAddress(0x20n)).toBe('0x20');
-        expect(formatAddress('not-a-number')).toBe('not-a-number');
+        for (const { input } of cases) {
+            await expect(targetAccess.evaluateSymbolName(input)).resolves.toBe('Sym');
+        }
+        expect(expectedExpressions).toHaveLength(0);
     });
 
     it('evaluates symbol address and handles failures', async () => {
@@ -91,6 +115,14 @@ describe('ComponentViewerTargetAccess', () => {
         );
     });
 
+    it('returns undefined without logging when exist check fails', async () => {
+        const debugSpy = jest.spyOn(componentViewerLogger, 'debug');
+        (debugSession.customRequest as jest.Mock).mockRejectedValueOnce(new Error('probe failed'));
+
+        await expect(targetAccess.evaluateSymbolAddress('missing', 'hover', true)).resolves.toBeUndefined();
+        expect(debugSpy).not.toHaveBeenCalled();
+    });
+
     it('evaluates symbol name with valid and missing results', async () => {
         (debugSession.customRequest as jest.Mock).mockResolvedValueOnce({ result: '0x20000000 <MySymbol>' });
         setActiveStackItem(debugSession, 1);
@@ -109,6 +141,9 @@ describe('ComponentViewerTargetAccess', () => {
         (debugSession.customRequest as jest.Mock).mockResolvedValueOnce({ result: 'No symbol matches' });
         await expect(targetAccess.evaluateSymbolName('0x0')).resolves.toBeUndefined();
 
+        (debugSession.customRequest as jest.Mock).mockResolvedValueOnce({ result: '0x20000000 Symbol' });
+        await expect(targetAccess.evaluateSymbolName('0x20000000')).resolves.toBeUndefined();
+
         const debugSpy = jest.spyOn(componentViewerLogger, 'debug');
         (debugSession.customRequest as jest.Mock).mockRejectedValueOnce(new Error('oops'));
         await expect(targetAccess.evaluateSymbolName('0x1')).resolves.toBeUndefined();
@@ -124,6 +159,9 @@ describe('ComponentViewerTargetAccess', () => {
         (debugSession.customRequest as jest.Mock).mockResolvedValueOnce({ result: 'No line information' });
         await expect(targetAccess.evaluateSymbolContext('0x100')).resolves.toBeUndefined();
 
+        (debugSession.customRequest as jest.Mock).mockResolvedValueOnce({ result: '' });
+        await expect(targetAccess.evaluateSymbolContext('0x100')).resolves.toBeUndefined();
+
         const debugSpy = jest.spyOn(componentViewerLogger, 'debug');
         (debugSession.customRequest as jest.Mock).mockRejectedValueOnce(new Error('context fail'));
         await expect(targetAccess.evaluateSymbolContext('0x100')).resolves.toBeUndefined();

Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ export class ScvdDebugTarget {`
`145`	`145`	`});`
`146`	`146`	`}`
`147`	`147`
`148`		`- public async getSymbolInfo(symbol: string): Promise<SymbolInfo \| undefined> {`
	`148`	`+ public async getSymbolInfo(symbol: string, existCheck: boolean = false): Promise<SymbolInfo \| undefined> {`
`149`	`149`	componentViewerLogger.debug(`get Symbol Info: resolving ${symbol}`);
`150`	`150`	`if (symbol === undefined) {`
`151`	`151`	`componentViewerLogger.debug('get Symbol Info: no symbol provided');`
`@@ -157,7 +157,7 @@ export class ScvdDebugTarget {`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`const addressInfo = await this.symbolCaches.getAddressWithName(symbol, async (symbolName) => {`
`160`		`- const symbolAddressStr = await this.targetAccess.evaluateSymbolAddress(symbolName);`
	`160`	`+ const symbolAddressStr = await this.targetAccess.evaluateSymbolAddress(symbolName, 'hover', existCheck);`
`161`	`161`	`if (symbolAddressStr !== undefined) {`
`162`	`162`	`const parsed = parseInt(symbolAddressStr as unknown as string, 16);`
`163`	`163`	`if (Number.isFinite(parsed)) {`
`@@ -242,9 +242,9 @@ export class ScvdDebugTarget {`
`242`	`242`	`return this.isTargetRunning;`
`243`	`243`	`}`
`244`	`244`
`245`		`- public async findSymbolAddress(symbol: string): Promise<number \| undefined> {`
	`245`	`+ public async findSymbolAddress(symbol: string, existCheck: boolean = false): Promise<number \| undefined> {`
`246`	`246`	componentViewerLogger.debug(`find Symbol Address: ${symbol}`);
`247`		`- const symbolInfo = await this.getSymbolInfo(symbol);`
	`247`	`+ const symbolInfo = await this.getSymbolInfo(symbol, existCheck);`
`248`	`248`	`return symbolInfo?.address;`
`249`	`249`	`}`
`250`	`250`
Original file line number	Diff line number	Diff line change
`@@ -169,12 +169,12 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr`
`169`	`169`	`return trimmed && trimmed.length > 0 ? trimmed : undefined;`
`170`	`170`	`}`
`171`	`171`
`172`		`- private async findSymbolAddressNormalized(name: string \| undefined): Promise<number \| undefined> {`
	`172`	`+ private async findSymbolAddressNormalized(name: string \| undefined, existCheck: boolean = false): Promise<number \| undefined> {`
`173`	`173`	`const normalized = this.normalizeName(name);`
`174`	`174`	`if (!normalized) {`
`175`	`175`	`return undefined;`
`176`	`176`	`}`
`177`		`- return this.debugTarget.findSymbolAddress(normalized);`
	`177`	`+ return this.debugTarget.findSymbolAddress(normalized, existCheck);`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`// ---------------- Host Interface: model + data access ----------------`
`@@ -347,7 +347,7 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr`
`347`	`347`	`}`
`348`	`348`
`349`	`349`	`public async __Symbol_exists(symbol: string): Promise<number \| undefined> {`
`350`		`- const found = await this.findSymbolAddressNormalized(symbol);`
	`350`	`+ const found = await this.findSymbolAddressNormalized(symbol, true);`
`351`	`351`	`return found !== undefined ? 1 : 0;`
`352`	`352`	`}`
`353`	`353`