When to skip nameless item (#846)

* different fixes
- reworked displaying <item> on conditions "print" and "value but no name"
- colon path
- some "not implemented" on Network.scvd
* fixed empty item handling

Author: thorstendb-ARM

src/views/component-viewer/model/scvd-typedef.ts

@@ -281,7 +281,7 @@ export class ScvdTypedef extends ScvdNode {
                     }
                 } else {
                     member.offset = currentNextOffset.toString();  // set current offset
-                    componentViewerLogger.error(`ScvdTypedef.calculateOffsets: no offset defined for member: ${member.name} in typedef: ${this.getDisplayLabel()}`);
+                    componentViewerLogger.warn(`ScvdTypedef.calculateOffsets: no offset defined for member: ${member.name} in typedef: ${this.getDisplayLabel()}`);
                 }
                 member.offset?.configure();
             }
@@ -299,7 +299,7 @@ export class ScvdTypedef extends ScvdNode {
             this.targetSize = size;
 
             if (currentNextOffset > size) {
-                componentViewerLogger.error(`ScvdTypedef.calculateOffsets: typedef size (${size}) smaller than members size (${currentNextOffset}) for ${this.getDisplayLabel()}`);
+                componentViewerLogger.warn(`ScvdTypedef.calculateOffsets: typedef size (${size}) smaller than members size (${currentNextOffset}) for ${this.getDisplayLabel()}`);
             } else if (currentNextOffset < size) {   // adjust to typedef size if padding is included
                 currentNextOffset = size;
             }

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

@@ -250,6 +250,8 @@ export class Evaluator {
                 return this.findReferenceNode(c.callee);
             }
             case 'EvalPointCall': {
+                // 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) {
@@ -259,6 +261,7 @@ export class Evaluator {
                         }
                     }
                 }
+                // If no args, fall back to callee (it's still an identifier node)
                 return this.findReferenceNode(c.callee);
             }
             case 'PrintfExpression': {
@@ -549,6 +552,13 @@ export class Evaluator {
                 resolved.push((arg as StringLiteral).value);
                 continue;
             }
+            // __Offset_of accepts ColonPath (type:member) as in C++ implementation
+            if (name === '__Offset_of' && arg.kind === 'ColonPath') {
+                const cp = arg as ColonPath;
+                // Convert ColonPath parts to "type:member" string format
+                resolved.push(cp.parts.join(':'));
+                continue;
+            }
             // Make the failure explicit; this avoids silently passing evaluated values like 0.
             this.diagnostics.record(`${name} expects identifier/string for argument ${idx + 1}, got ${arg.kind}`);
             perf?.end(perfStartTime, 'evalIntrinsicArgsMs', 'evalIntrinsicArgsCalls');
@@ -602,7 +612,12 @@ export class Evaluator {
                     }
                     if (!ref) {
                         perf?.end(perfStartKind, 'evalMustRefIdentifierMs', 'evalMustRefIdentifierCalls');
-                        this.diagnostics.record(`Unknown symbol '${id.name}' in ${this.diagnostics.formatNodeForMessage(node)}`);
+                        // Check if this is an intrinsic function name being used as an identifier
+                        if (isIntrinsicName(id.name)) {
+                            this.diagnostics.record(`Intrinsic function '${id.name}' cannot be used as an identifier. Use it as a function call: ${id.name}(...)`);
+                        } else {
+                            this.diagnostics.record(`Unknown symbol '${id.name}' in ${this.diagnostics.formatNodeForMessage(node)}`);
+                        }
                         return undefined;
                     }
                     // Start a new anchor chain at this identifier

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

@@ -275,6 +275,26 @@ function constValueFromCValue(value: { type: { kind: string }, value: bigint | n
     return Number(bigintValue);
 }
 
+/**
+ * Validates that a string doesn't contain leftover XML entity references.
+ * Returns undefined if valid, or an error message if XML entities are detected.
+ *
+ * Common XML entities that should be decoded before parsing:
+ * - &  → &
+ * - &lt;   → <
+ * - &gt;   → >
+ * - &quot; → "
+ * - &apos; → '
+ */
+export function validateNoXmlEntities(expr: string): string | undefined {
+    const xmlEntityPattern = /&(amp|lt|gt|quot|apos|#\d+|#x[0-9a-fA-F]+);/;
+    const match = xmlEntityPattern.exec(expr);
+    if (match) {
+        return `Expression contains undecoded XML entity '${match[0]}'. XML attributes should be decoded before parsing.`;
+    }
+    return undefined;
+}
+
 function unescapeString(rawWithQuotes: string): string {
     const s = rawWithQuotes.slice(1, -1);
     let out = '';
@@ -417,6 +437,13 @@ export class Parser {
 
     public parse(input: string, isPrintExpression: boolean): ParseResult {
         this.reinit(input);
+
+        // Check for leftover XML entities before parsing
+        const xmlError = validateNoXmlEntities(input);
+        if (xmlError) {
+            this.warn(xmlError, 0, input.length);
+        }
+
         let ast: ASTNode;
         let isPrintf = false;
 

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

@@ -27,6 +27,8 @@ import { ScvdMember } from './model/scvd-member';
 import { ScvdVar } from './model/scvd-var';
 import { perf } from './stats-config';
 import { ScvdEvalInterfaceCache } from './scvd-eval-interface-cache';
+import { ScvdComponentViewer } from './model/scvd-component-viewer';
+import { ScvdTypedef } from './model/scvd-typedef';
 
 export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicProvider {
     private static readonly INVALID_ADDR_MIN = 0xFFFFFFF0;
@@ -115,11 +117,16 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr
         }
 
         // Determine element width: prefer target size, then container hint, then byte-width helper.
-        let widthBytes: number | undefined = currentRef?.getTargetSize ? await currentRef.getTargetSize() : undefined;
+        // Only query target size if we have a resolved reference (not just the base container)
+        let widthBytes: number | undefined;
+        if (container.current && currentRef?.getTargetSize) {
+            widthBytes = await currentRef.getTargetSize();
+        }
         if ((!widthBytes || widthBytes <= 0) && container.widthBytes) {
             widthBytes = container.widthBytes;
         }
-        if ((!widthBytes || widthBytes <= 0) && typeof this.getByteWidth === 'function' && currentRef) {
+        // Only call getByteWidth if we have a resolved reference (not just the base container)
+        if ((!widthBytes || widthBytes <= 0) && currentRef && container.current) {
             const w = await this.getByteWidth(currentRef);
             if (typeof w === 'number' && w > 0) {
                 widthBytes = w;
@@ -202,7 +209,21 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr
         return ref;
     }
 
-    public async resolveColonPath(_container: RefContainer, _parts: string[]): Promise<EvalValue> {
+    public async resolveColonPath(_container: RefContainer, parts: string[]): Promise<EvalValue> {
+        // ColonPath in general expression context (not inside __Offset_of)
+        // Example: typedef:member evaluates to the offset value itself
+        // This matches C++ behavior where type:member expressions can be used directly
+
+        if (parts.length === 2) {
+            const [typedefName, memberName] = parts;
+            const colonPath = `${typedefName}:${memberName}`;
+
+            // Reuse __Offset_of logic which handles typedef:member resolution
+            const offset = await this.__Offset_of(_container, colonPath);
+            return offset;
+        }
+
+        componentViewerLogger.warn(`[resolveColonPath] Unsupported colon path format with ${parts.length} parts: ${parts.join(':')}`);
         return undefined;
     }
 
@@ -387,11 +408,62 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr
     public async __Offset_of(container: RefContainer, typedefMember: string): Promise<number | undefined> {
         const perfStartTime = perf?.start() ?? 0;
         try {
-            const memberRef = container.base.getMember(typedefMember);
-            if (memberRef) {
+            // Handle both "member" and "typedef:member" formats
+            const parts = typedefMember.split(':');
+
+            if (parts.length === 1) {
+                // Simple member lookup from current container
+                const memberRef = container.base.getMember(typedefMember);
+                if (memberRef) {
+                    const offset = await memberRef.getMemberOffset();
+                    return offset;
+                }
+                return undefined;
+            }
+
+            if (parts.length === 2) {
+                // ColonPath format: "TypedefName:MemberName"
+                const [typedefName, memberName] = parts;
+
+                // Find the root ScvdComponentViewer to access typedefs
+                let root: ScvdNode = container.base;
+                while (root.parent !== undefined) {
+                    root = root.parent;
+                }
+
+                // Navigate to typedefs and find the specified typedef
+                if (!(root instanceof ScvdComponentViewer)) {
+                    componentViewerLogger.error('[__Offset_of] Root is not ScvdComponentViewer');
+                    return undefined;
+                }
+
+                const typedefs = root.typedefs;
+                if (!typedefs || !typedefs.typedef) {
+                    componentViewerLogger.error('[__Offset_of] No typedefs found in component viewer');
+                    return undefined;
+                }
+
+                const typedef = typedefs.typedef.find((td: ScvdTypedef) => td.name === typedefName);
+                if (!typedef) {
+                    componentViewerLogger.error(`[__Offset_of] Typedef "${typedefName}" not found`);
+                    return undefined;
+                }
+
+                // Get the member from the typedef
+                const memberRef = typedef.getMember(memberName);
+                if (!memberRef) {
+                    componentViewerLogger.error(`[__Offset_of] Member "${memberName}" not found in typedef "${typedefName}"`);
+                    return undefined;
+                }
+
                 const offset = await memberRef.getMemberOffset();
+                if (offset === undefined) {
+                    componentViewerLogger.warn(`[__Offset_of] Member "${memberName}" in typedef "${typedefName}" has undefined offset`);
+                }
                 return offset;
             }
+
+            componentViewerLogger.error(`[__Offset_of] Invalid format: "${typedefMember}". Expected "member" or "typedef:member"`);
             return undefined;
         } finally {
             perf?.end(perfStartTime, 'symbolOffsetMs', 'symbolOffsetCalls');

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

@@ -51,47 +51,66 @@ export class StatementItem extends StatementBase {
     protected override async onExecute(executionContext: ExecutionContext, guiTree: ScvdGuiTree): Promise<void> {
         componentViewerLogger.debug(`Line: ${this.line}: Executing <${this.scvdItem.tag}> : ${await this.getLogName()}`);
 
-        const guiNameStart = perf?.start() ?? 0;
-        const guiName = await this.getGuiName();
-        perf?.end(guiNameStart, 'guiNameMs', 'guiNameCalls');
-        const childGuiTree = this.getOrCreateGuiChild(guiTree, guiName);
-        perf?.recordGuiItemNode();
-        const guiValueStart = perf?.start() ?? 0;
-        const guiValue = await this.getGuiValue();
-        perf?.end(guiValueStart, 'guiValueMs', 'guiValueCalls');
-        childGuiTree.setGuiName(guiName);
-        childGuiTree.setGuiValue(guiValue);
-
         const printChildren = this.children.filter((child): child is StatementPrint => child instanceof StatementPrint);
+
+        // Determine the name and value for this item
+        let guiName = '';
+        let guiValue = '';
+
         if (printChildren.length > 0) {
+            // Item uses print children for name/value - check if any print condition matches
             let matched = false;
             for (const printChild of printChildren) {
                 const shouldPrint = await printChild.scvdItem.getConditionResult();
                 if (shouldPrint !== false) {
-                    const guiNamePrint = await printChild.scvdItem.getGuiName();
-                    const guiValuePrint = await printChild.scvdItem.getGuiValue();
-                    childGuiTree.setGuiName(guiNamePrint);
-                    childGuiTree.setGuiValue(guiValuePrint);
+                    guiName = await printChild.scvdItem.getGuiName() ?? '';
+                    guiValue = await printChild.scvdItem.getGuiValue() ?? '';
                     matched = true;
                     break;
                 }
             }
             if (!matched) {
-                childGuiTree.detach();
+                // No print matched - skip this entire item and its subtree
                 return;
             }
-            for (const child of this.children) {
-                if (!(child instanceof StatementPrint)) {
-                    await child.executeStatement(executionContext, childGuiTree);
-                }
-            }
-            return;
+        } else {
+            // Item uses its own property/value attributes
+            const guiNameStart = perf?.start() ?? 0;
+            guiName = await this.getGuiName() ?? '';
+            perf?.end(guiNameStart, 'guiNameMs', 'guiNameCalls');
+            const guiValueStart = perf?.start() ?? 0;
+            guiValue = await this.getGuiValue() ?? '';
+            perf?.end(guiValueStart, 'guiValueMs', 'guiValueCalls');
         }
 
-        if (this.children.length > 0) {
-            for (const child of this.children) {
+        // Create the GUI node
+        const childGuiTree = this.getOrCreateGuiChild(guiTree, guiName);
+        perf?.recordGuiItemNode();
+        childGuiTree.setGuiName(guiName);
+        childGuiTree.setGuiValue(guiValue);
+
+        // Execute non-print children
+        for (const child of this.children) {
+            if (!(child instanceof StatementPrint)) {
                 await child.executeStatement(executionContext, childGuiTree);
             }
         }
+
+        // Remove item if it has statement children but no meaningful result:
+        // - No value AND no GUI children after execution (e.g., "Drives" container with empty list)
+        // - OR no name, no value, AND has children (e.g., empty Drive with Status child)
+        const hasNonPrintChildren = this.children.some(child => !(child instanceof StatementPrint));
+        const hasName = guiName.trim() !== '';
+        const hasValue = guiValue.trim() !== '';
+
+        if (hasNonPrintChildren) {
+            // For containers: remove if no value and no GUI children
+            if (!hasValue && !childGuiTree.hasGuiChildren()) {
+                childGuiTree.detach();
+            // Also remove if no name, no value (even if it has GUI children that will display)
+            } else if (!hasName && !hasValue) {
+                childGuiTree.detach();
+            }
+        }
     }
 }

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

@@ -33,6 +33,7 @@ const makeStubBase = (name: string): ScvdNode => ({
     getMember: jest.fn(),
     getDisplayLabel: jest.fn().mockReturnValue(name),
     getValueType: jest.fn(),
+    getArraySize: jest.fn().mockResolvedValue(undefined),
 } as unknown as ScvdNode);
 
 const makeContainer = (name: string, widthBytes: number, offsetBytes = 0): RefContainer => ({