fix: invalid type property check led to failed tests

Author: ashenBlade

src/debugger.ts

@@ -553,6 +553,11 @@ export abstract class GenericDebuggerFacade implements IDebuggerFacade, vscode.D
     }
 
     isScalarType(variable: IDebugVariable, type?: string) {
+        const value = this.getValue(variable);
+        if (value.startsWith('0x')) {
+            return false;
+        }
+
         return builtInTypes.has(type ?? variable.type);
     }
 
@@ -897,10 +902,6 @@ export class CodeLLDBDebuggerFacade extends GenericDebuggerFacade {
         return scope.name === 'Local';
     }
 
-    valueRepresentsStructure(value: string) {
-        return value.startsWith('{') && value.endsWith('}');
-    }
-
     async evaluate(expression: string, frameId: number | undefined, context?: string, noReturn?: boolean): Promise<dap.EvaluateResponse> {
         try {
             context ??= 'watch';
@@ -956,6 +957,22 @@ export class CodeLLDBDebuggerFacade extends GenericDebuggerFacade {
 
         return nullRegex.test(variable.value);
     }
+
+    private isPointerValue(value: string) {
+        if (value === '<null>' || value === '<invalid address>') {
+            return true;
+        }
+
+        if (value === '0x0') {
+            return true;
+        }
+        
+        if (value.startsWith('0x')) {
+            return true;
+        }
+        
+        return pointerRegex.test(value);
+    }
 
     isValidPointerType(variable: IDebugVariable | dap.EvaluateResponse): boolean {
         if ('result' in variable) {
@@ -977,15 +994,37 @@ export class CodeLLDBDebuggerFacade extends GenericDebuggerFacade {
     }
 
     isScalarType(variable: IDebugVariable, type?: string) {
+        if ((type ?? variable.type).indexOf('*') !== -1) {
+            return false;
+        }
+        
+        if ((type ?? variable.type).indexOf('[]') !== -1) {
+            /* flexible array member */
+            return false;
+        }
+
         /* 
          * CodeLLDB displays structures in 'description', so we can use
          * this info to figure out, that even if type is not builtin, it
          * is actually not a struct.
          * 'valueRepresentsStructure' also covers case, when 'description'
          * is array - it rendered as '{1, 2, 3, ...}'.
          */
-        return super.isScalarType(variable, type) || 
-              !this.valueRepresentsStructure(variable.value);
+        if (super.isScalarType(variable, type)) {
+            return true;
+        }
+
+        const value = this.getValue(variable);
+        
+        if (value.startsWith('{') && value.endsWith('}')) {
+            return false;
+        }
+        
+        if (this.isPointerValue(value)) {
+            return false;
+        }
+        
+        return true;
     }
 
     isValueStruct(variable: IDebugVariable, type?: string): boolean {

src/variables.ts

@@ -1225,7 +1225,7 @@ export abstract class Variable {
             type: effectiveType,
             declaredType: debugVariable.type,
         };
-        
+
         /* Value struct or scalar types are not so interesting for us */
         if (   context.debug.isValueStruct(debugVariable, effectiveType)
             || context.debug.isScalarType(debugVariable, effectiveType)) {
@@ -1248,16 +1248,20 @@ export abstract class Variable {
         /*
          * Pointer types can be NULL or contain invalid pointers.
          * cppdbg do not recognize invalid pointers, but CodeLLDB - <invalid pointer>.
+         * 
+         * For such variables use special InvalidVariable, which do not
+         * act like RealVariable, so it prevent some potential errors.
          */
-        if (!context.debug.isValidPointerType(debugVariable)) {
+        if (!(   context.debug.isValidPointerType(debugVariable) 
+              || context.debug.isFixedSizeArray(debugVariable))) {
             /* 
              * We are here if got scalar type or value struct (not pointer).
              * These types are not so interesting for us, so pass here to
              * quickly return usual variable.
              */
 
             if (   context.debug.isNull(debugVariable)
-                && debugVariable.type.endsWith('List *')) {
+                && effectiveType.endsWith('List *')) {
                 /* 
                  * Empty List is NIL == NULL == '0x0' Also 'endsWith'
                  * covers cases like 'const List *'.
@@ -1275,7 +1279,7 @@ export abstract class Variable {
                 return new ListNodeVariable('List', args);
             }
 
-            if (parent && dbg.isFlexibleArrayMember(debugVariable.type)) {
+            if (parent && dbg.isFlexibleArrayMember(effectiveType)) {
                 /* 
                  * Flexible array members for now recognized as non-valid
                  * pointers/scalars, but we actually can handle them.
@@ -1288,7 +1292,7 @@ export abstract class Variable {
                 }
             }
 
-            return new InvalidPointerType(args);
+            return new InvalidVariable(args);
         }
 
         /* 
@@ -1618,7 +1622,7 @@ class ScalarVariable extends Variable {
     }
 }
 
-class InvalidPointerType extends Variable {
+class InvalidVariable extends Variable {
     constructor(args: RealVariableArgs) {
         super(args.name, args.value, args.type, args.declaredType,
               args.context, args.frameId, args.parent);
@@ -1817,8 +1821,12 @@ export class RealVariable extends Variable {
         if (m instanceof RealVariable) {
             return m;
         }
+        
+        if (m instanceof InvalidVariable) {
+            return;
+        }
 
-        throw new EvaluationError(`member "${member}" is not RealVariable`);
+        throw new EvaluationError(`member "${member}" is neither RealVariable nor InvalidPointer`);
     }
 
     /**
@@ -2469,7 +2477,7 @@ class ExprNodeVariable extends NodeVariable {
             }
 
             const alias = await rte.getRealMember('alias');
-            if (alias.isValidPointer()) {
+            if (alias) {
                 const aliasColnames = await alias.getListMemberElements('colnames');
 
                 if (varattno <= aliasColnames.length) {
@@ -2534,7 +2542,7 @@ class ExprNodeVariable extends NodeVariable {
             }
 
             const eref = await rte.getRealMember('eref');
-            if (eref.isValidPointer()) {
+            if (eref) {
                 const erefColnames = await eref.getListMemberElements('colnames');
                 if (varattno <= erefColnames.length) {
                     const colname = erefColnames[varattno - 1];