Fix colon path and __size_of evaluation (#889)

* Fix colon path and __size_of evaluation

Co-authored-by: Jens Reinecke <jens.reinecke@arm.com>

Author: thorstendb-ARM

src/views/component-viewer/parser-evaluator/evaluator.ts

@@ -253,16 +253,14 @@ export class Evaluator {
                 // For intrinsic calls, the callee is metadata (intrinsic name), not a reference to evaluate.
                 // Only search the arguments for references.
                 const c = node as EvalPointCall;
-                if (c.args.length) {
-                    for (const arg of c.args) {
-                        const r = this.findReferenceNode(arg);
-                        if (r) {
-                            return r;
-                        }
+                for (const arg of c.args) {
+                    const r = this.findReferenceNode(arg);
+                    if (r) {
+                        return r;
                     }
                 }
-                // If no args, fall back to callee (it's still an identifier node)
-                return this.findReferenceNode(c.callee);
+                // Never fall back to callee – intrinsic names are not data references.
+                return undefined;
             }
             case 'PrintfExpression': {
                 for (const seg of (node as PrintfExpression).segments) {

src/views/component-viewer/scvd-eval-interface.ts

@@ -223,10 +223,66 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr
             return offset;
         }
 
+        // 3-part colon path: typedef:member:enumName → numeric enum value
+        if (parts.length === 3) {
+            const [typedefName, memberName, enumName] = parts;
+            return this.resolveEnumValue(_container, typedefName, memberName, enumName);
+        }
+
         componentViewerLogger.warn(`[resolveColonPath] Unsupported colon path format with ${parts.length} parts: ${parts.join(':')}`);
         return undefined;
     }
 
+    /**
+     * Resolve a 3-part colon path `typedef:member:enumName` to the numeric enum value.
+     * E.g. `TCP_INFO4:State:Closed` → 1
+     */
+    private async resolveEnumValue(_container: RefContainer, typedefName: string, memberName: string, enumName: string): Promise<EvalValue> {
+        // Navigate to the root ScvdComponentViewer
+        let root: ScvdNode = _container.base;
+        while (root.parent !== undefined) {
+            root = root.parent;
+        }
+
+        if (!(root instanceof ScvdComponentViewer)) {
+            componentViewerLogger.error('[resolveEnumValue] Root is not ScvdComponentViewer');
+            return undefined;
+        }
+
+        const typedefs = root.typedefs;
+        if (!typedefs || !typedefs.typedef) {
+            componentViewerLogger.error('[resolveEnumValue] No typedefs found in component viewer');
+            return undefined;
+        }
+
+        const typedef = typedefs.typedef.find((td: ScvdTypedef) => td.name === typedefName);
+        if (!typedef) {
+            componentViewerLogger.error(`[resolveEnumValue] Typedef "${typedefName}" not found`);
+            return undefined;
+        }
+
+        const memberRef = typedef.getMember(memberName);
+        if (!memberRef || !(memberRef instanceof ScvdMember)) {
+            componentViewerLogger.error(`[resolveEnumValue] Member "${memberName}" not found in typedef "${typedefName}"`);
+            return undefined;
+        }
+
+        // Find the enum by name within the member
+        const enumItem = memberRef.enum.find(e => e.name === enumName);
+        if (!enumItem) {
+            componentViewerLogger.error(`[resolveEnumValue] Enum "${enumName}" not found in member "${memberName}" of typedef "${typedefName}"`);
+            return undefined;
+        }
+
+        const value = await enumItem.value?.getValue();
+        if (typeof value !== 'number') {
+            componentViewerLogger.warn(`[resolveEnumValue] Enum "${enumName}" value is not a number: ${value}`);
+            return undefined;
+        }
+
+        return value;
+    }
+
     public async getElementRef(ref: ScvdNode): Promise<ScvdNode | undefined> {
         return ref.getElementRef();
     }

src/views/component-viewer/statement-engine/statement-readList.ts

@@ -293,7 +293,7 @@ export class StatementReadList extends StatementBase {
         if (!didBatchRead) {
             const loopStart = perf?.start() ?? 0;
             let readIdx = 0;
-            const visitedAddresses = new Set<number | bigint>();
+            const visitedAddresses = new Set<number>();
             while (nextPtrAddr !== undefined) {
                 // Check for external cancellation (session ended) or global timeout
                 if (executionContext.cancellation.checkDeadline()) {
@@ -303,12 +303,24 @@ export class StatementReadList extends StatementBase {
 
                 const itemAddress: number | bigint | undefined = typeof nextPtrAddr === 'bigint' ? nextPtrAddr : (nextPtrAddr >>> 0);
 
+                // Normalize to number for consistent Set lookups (bigint and number
+                // are different types in Set — 42n !== 42 — so always use number).
+                const addressKey = typeof itemAddress === 'bigint' ? Number(itemAddress) : itemAddress;
+
                 // Detect cycles: check if we've visited this address before
-                if (visitedAddresses.has(itemAddress)) {
-                    componentViewerLogger.error(`${this.scvdItem.getLineNoStr()}: Executing "readlist": ${scvdReadList.name}, symbol: ${symbol?.name}, detected cycle in linked list at address: ${itemAddress.toString(16)}`);
+                if (visitedAddresses.has(addressKey)) {
+                    const message = `${this.scvdItem.getLineNoStr()}: Executing "readlist": ${scvdReadList.name}, symbol: ${symbol?.name}, detected cycle in linked list at address: ${itemAddress.toString(16)}`;
+                    if (await executionContext.debugTarget.getTargetIsRunning()) {
+                        // While the target is running, cycles may be caused by the RTOS
+                        // updating linked-list pointers concurrently — this is transient
+                        // and not necessarily an error in the SCVD definition.
+                        componentViewerLogger.warn(message);
+                    } else {
+                        componentViewerLogger.error(message);
+                    }
                     break;
                 }
-                visitedAddresses.add(itemAddress);
+                visitedAddresses.add(addressKey);
 
                 // Read data from target
                 const readData = await executionContext.debugTarget.readMemory(itemAddress, readBytes);

src/views/component-viewer/test/integration/parser-evaluator/evaluator/evaluator.guards.test.ts

@@ -86,7 +86,7 @@ describe('evaluator guards', () => {
         expect(fn(assignNode)).toBe(assignNode.right);
 
         const evalPoint: ASTNode = { kind: 'EvalPointCall', intrinsic: '__Running', callee: { kind: 'Identifier', name: '__Running', start: 0, end: 0 }, args: [], start: 0, end: 0 } as unknown as ASTNode;
-        expect(fn(evalPoint)).toBe((evalPoint as CallExpression).callee);
+        expect(fn(evalPoint)).toBeUndefined();
 
         const evalPointWithArg: ASTNode = {
             kind: 'EvalPointCall',

src/views/component-viewer/test/unit/helpers/statement-engine-helpers.ts

@@ -90,6 +90,7 @@ export function createExecutionContext(
         readMemory: async () => undefined,
         readMemoryBatch: async () => new Map(),
         beginUpdateCycle: async () => {},
+        getTargetIsRunning: async () => false,
     };
     const debugTarget = { ...debugTargetDefaults, ...debugTargetOverrides } as ScvdDebugTarget;
 

src/views/component-viewer/test/unit/parser-evaluator/eval-interface/scvd-eval-interface.test.ts

@@ -30,7 +30,7 @@ import { ScvdFormatSpecifier } from '../../../../model/scvd-format-specifier';
 import { ScvdNode } from '../../../../model/scvd-node';
 import { ScvdMember } from '../../../../model/scvd-member';
 import { ScvdComponentViewer } from '../../../../model/scvd-component-viewer';
-import { ScvdTypedef } from '../../../../model/scvd-typedef';
+import { ScvdTypedef, ScvdTypedefs } from '../../../../model/scvd-typedef';
 
 class DummyNode extends ScvdNode {
     private _testParent: ScvdNode | undefined;
@@ -304,16 +304,136 @@ describe('ScvdEvalInterface intrinsics and helpers', () => {
         await expect(evalIf.getElementRef(base)).resolves.toBeUndefined();
     });
 
-    it('resolveColonPath warns on unsupported path format with more than 2 parts', async () => {
+    it('resolveColonPath attempts enum lookup for 3-part path (falls back gracefully)', async () => {
         const base = new DummyNode('base');
         const container: RefContainer = { base, current: base, valueType: undefined };
         const { evalIf } = makeEval();
-        jest.spyOn(componentViewerLogger, 'warn').mockImplementation(() => {});
+        jest.spyOn(componentViewerLogger, 'error').mockImplementation(() => {});
+        // 3-part path now tries enum resolution; DummyNode root is not ScvdComponentViewer so it fails gracefully
         await expect(evalIf.resolveColonPath(container, ['a', 'b', 'c'])).resolves.toBeUndefined();
-        expect(componentViewerLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Unsupported colon path format with 3 parts'));
+        expect(componentViewerLogger.error).toHaveBeenCalledWith(expect.stringContaining('Root is not ScvdComponentViewer'));
+        (componentViewerLogger.error as unknown as jest.Mock).mockRestore();
+    });
+
+    it('resolveColonPath warns on unsupported path format with more than 3 parts', async () => {
+        const base = new DummyNode('base');
+        const container: RefContainer = { base, current: base, valueType: undefined };
+        const { evalIf } = makeEval();
+        jest.spyOn(componentViewerLogger, 'warn').mockImplementation(() => {});
+        await expect(evalIf.resolveColonPath(container, ['a', 'b', 'c', 'd'])).resolves.toBeUndefined();
+        expect(componentViewerLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Unsupported colon path format with 4 parts'));
         (componentViewerLogger.warn as unknown as jest.Mock).mockRestore();
     });
 
+    describe('resolveEnumValue (3-part colon path)', () => {
+        function buildComponentViewerWithEnum(opts?: {
+            typedefName?: string;
+            memberName?: string;
+            enumName?: string;
+            enumValue?: number | string;
+            skipTypedefs?: boolean;
+            skipTypedef?: boolean;
+            skipMember?: boolean;
+            skipEnum?: boolean;
+        }): { root: ScvdComponentViewer; container: RefContainer } {
+            const root = new ScvdComponentViewer(undefined);
+
+            if (!opts?.skipTypedefs) {
+                const typedefs = new ScvdTypedefs(root);
+                (root as unknown as { _typedefs: ScvdTypedefs })._typedefs = typedefs;
+
+                if (!opts?.skipTypedef) {
+                    const typedef = new ScvdTypedef(typedefs);
+                    typedef.name = opts?.typedefName ?? 'MyType';
+                    typedefs.typedef.push(typedef);
+
+                    if (!opts?.skipMember) {
+                        const member = typedef.addMember();
+                        member.name = opts?.memberName ?? 'State';
+
+                        if (!opts?.skipEnum) {
+                            const enumItem = member.addEnum();
+                            enumItem.name = opts?.enumName ?? 'Active';
+                            // Mock getValue on the enum's value expression
+                            const mockValue = opts?.enumValue ?? 42;
+                            jest.spyOn(enumItem.value, 'getValue').mockResolvedValue(
+                                typeof mockValue === 'number' ? mockValue : mockValue
+                            );
+                        }
+                    }
+                }
+            }
+
+            // Create a DummyNode whose parent chain leads to root
+            const base = new DummyNode('child');
+            base.setTestParent(root);
+            const container: RefContainer = { base, current: base, valueType: undefined };
+            return { root, container };
+        }
+
+        it('resolves enum value for valid 3-part colon path', async () => {
+            const { container } = buildComponentViewerWithEnum({
+                typedefName: 'TCP_INFO4',
+                memberName: 'State',
+                enumName: 'Closed',
+                enumValue: 1,
+            });
+            const { evalIf } = makeEval();
+            await expect(evalIf.resolveColonPath(container, ['TCP_INFO4', 'State', 'Closed'])).resolves.toBe(1);
+        });
+
+        it('returns undefined when typedefs are missing', async () => {
+            const { container } = buildComponentViewerWithEnum({ skipTypedefs: true });
+            const { evalIf } = makeEval();
+            jest.spyOn(componentViewerLogger, 'error').mockImplementation(() => {});
+            await expect(evalIf.resolveColonPath(container, ['a', 'b', 'c'])).resolves.toBeUndefined();
+            expect(componentViewerLogger.error).toHaveBeenCalledWith(expect.stringContaining('No typedefs found'));
+            (componentViewerLogger.error as unknown as jest.Mock).mockRestore();
+        });
+
+        it('returns undefined when typedef not found', async () => {
+            const { container } = buildComponentViewerWithEnum({ typedefName: 'Existing' });
+            const { evalIf } = makeEval();
+            jest.spyOn(componentViewerLogger, 'error').mockImplementation(() => {});
+            await expect(evalIf.resolveColonPath(container, ['NonExistent', 'State', 'Active'])).resolves.toBeUndefined();
+            expect(componentViewerLogger.error).toHaveBeenCalledWith(expect.stringContaining('Typedef "NonExistent" not found'));
+            (componentViewerLogger.error as unknown as jest.Mock).mockRestore();
+        });
+
+        it('returns undefined when member not found in typedef', async () => {
+            const { container } = buildComponentViewerWithEnum({ typedefName: 'MyType', memberName: 'State' });
+            const { evalIf } = makeEval();
+            jest.spyOn(componentViewerLogger, 'error').mockImplementation(() => {});
+            await expect(evalIf.resolveColonPath(container, ['MyType', 'WrongMember', 'Active'])).resolves.toBeUndefined();
+            expect(componentViewerLogger.error).toHaveBeenCalledWith(expect.stringContaining('Member "WrongMember" not found'));
+            (componentViewerLogger.error as unknown as jest.Mock).mockRestore();
+        });
+
+        it('returns undefined when enum not found in member', async () => {
+            const { container } = buildComponentViewerWithEnum({ enumName: 'Active' });
+            const { evalIf } = makeEval();
+            jest.spyOn(componentViewerLogger, 'error').mockImplementation(() => {});
+            await expect(evalIf.resolveColonPath(container, ['MyType', 'State', 'WrongEnum'])).resolves.toBeUndefined();
+            expect(componentViewerLogger.error).toHaveBeenCalledWith(expect.stringContaining('Enum "WrongEnum" not found'));
+            (componentViewerLogger.error as unknown as jest.Mock).mockRestore();
+        });
+
+        it('returns undefined when enum value is not a number', async () => {
+            const { container } = buildComponentViewerWithEnum({ enumValue: 'not-a-number' as unknown as number });
+            const { evalIf } = makeEval();
+            jest.spyOn(componentViewerLogger, 'warn').mockImplementation(() => {});
+            await expect(evalIf.resolveColonPath(container, ['MyType', 'State', 'Active'])).resolves.toBeUndefined();
+            expect(componentViewerLogger.warn).toHaveBeenCalledWith(expect.stringContaining('value is not a number'));
+            (componentViewerLogger.warn as unknown as jest.Mock).mockRestore();
+        });
+
+        it('returns enum value 0 correctly (falsy but valid)', async () => {
+            const { container } = buildComponentViewerWithEnum({ enumValue: 0 });
+            const { evalIf } = makeEval();
+            await expect(evalIf.resolveColonPath(container, ['MyType', 'State', 'Active'])).resolves.toBe(0);
+        });
+    });
+
     it('read/write value wrap host errors', async () => {
         const memHost = {
             readValue: jest.fn(() => { throw new Error('boom'); }),

src/views/component-viewer/test/unit/parser-evaluator/evaluator/evaluator.test.ts

@@ -1051,7 +1051,7 @@ describe('Evaluator coverage branches', () => {
         expect(helpers.findReferenceNode(callExpr(id('fn'), [num(1), id('arg')]))?.kind).toBe('Identifier');
         expect(helpers.findReferenceNode(callExpr(id('fn'), [num(1), num(2)]))?.kind).toBe('Identifier');
         expect(helpers.findReferenceNode(callExpr(id('fn'), []))?.kind).toBe('Identifier');
-        expect(helpers.findReferenceNode(evalPoint('__Running', []))?.kind).toBe('Identifier');
+        expect(helpers.findReferenceNode(evalPoint('__Running', []))).toBeUndefined();
         expect(helpers.findReferenceNode(evalPoint('__size_of', [num(1), id('sym')]))?.kind).toBe('Identifier');
         expect(helpers.findReferenceNode(evalPoint('__size_of', [id('sym')]))?.kind).toBe('Identifier');
         expect(helpers.findReferenceNode({ kind: 'ConditionalExpression', test: num(0), consequent: id('c'), alternate: num(2), ...span } as ConditionalExpression)?.kind).toBe('Identifier');