fix: internal state was stored in configuration file after mutation

For simplicity ConfigurationFile object is serialized and saved to disk
without any DTO, but that caused some internal state/representation to
also be stored to file.

To fix this internal state was changed:

- Some fields are renamed, i.e. 'lengthExpr' -> 'lengthExpression'
- Remove 'canIterate' field from simplehash entry - now entry is removed
  from Map if we can not iterate it. This is also a performance
  improvement.

Author: ashenBlade

src/configuration.ts

@@ -120,31 +120,31 @@ function parseConfiguration(configFile: unknown): ConfigurationFile | undefined
             }
         }
 
-        let lengthExpr;
+        let lengthExpression;
         if ('lengthExpression' in obj) {
-            lengthExpr = obj.lengthExpression;
-            if (!lengthExpr) {
+            lengthExpression = obj.lengthExpression;
+            if (!lengthExpression) {
                 vscode.window.showErrorMessage(`lengthExpression not provided for: ${typeName}->${memberName}`);
                 return;
             }
 
-            if (typeof lengthExpr !== 'string') {
+            if (typeof lengthExpression !== 'string') {
                 vscode.window.showErrorMessage(`lengthExpression field must be string for: ${typeName}->${memberName}`);
                 return;
             }
 
-            lengthExpr = lengthExpr.trim();
-            if (!lengthExpr.length) {
+            lengthExpression = lengthExpression.trim();
+            if (!lengthExpression.length) {
                 vscode.window.showErrorMessage('lengthExpression can not be empty string');
                 return;
             }
         }
 
-        if (typeName && memberName && lengthExpr) {
+        if (typeName && memberName && lengthExpression) {
             return {
                 typeName,
                 memberName,
-                lengthExpr,
+                lengthExpression,
             };
         }
     };
@@ -367,7 +367,7 @@ function parseConfiguration(configFile: unknown): ConfigurationFile | undefined
         return elements;
     };
 
-    const parseSimplehashTypes = (obj: unknown): vars.SimplehashEntryInfo[] | undefined => {
+    const parseSimplehashTypes = (obj: unknown) => {
         /* 
          * [
          *     {
@@ -380,13 +380,12 @@ function parseConfiguration(configFile: unknown): ConfigurationFile | undefined
             return;
         }
 
-        const elements = [];
+        const elements: vars.SimplehashEntryInfo[] = [];
         for (const o of obj) {
             if (!(typeof o === 'object' && o)) {
                 continue;
             }
 
-
             const prefix = o.prefix;
             const type = o.type;
 
@@ -395,11 +394,7 @@ function parseConfiguration(configFile: unknown): ConfigurationFile | undefined
                 continue;
             }
 
-            elements.push({
-                prefix,
-                canIterate: true,
-                elementType: type,
-            } as vars.SimplehashEntryInfo);
+            elements.push({prefix, type});
         }
 
         return elements;

src/constants.ts

@@ -1,4 +1,4 @@
-import { BitmaskMemberInfo,
+import { ArraySpecialMemberInfo, BitmaskMemberInfo,
          HtabEntryInfo,
          ListPtrSpecialMemberInfo,
          SimplehashEntryInfo,
@@ -1393,11 +1393,11 @@ export interface ArraySpecialMember {
     lengthExpr: string
 }
 
-export function getArraySpecialMembers(): ArraySpecialMember[] {
-    const _ = (typeName: string, memberName: string, lengthExpr: string) => ({
+export function getArraySpecialMembers(): ArraySpecialMemberInfo[] {
+    const _ = (typeName: string, memberName: string, lengthExpression: string) => ({
         typeName,
         memberName,
-        lengthExpr,
+        lengthExpression,
     });
 
     return [
@@ -2147,9 +2147,7 @@ export function getWellKnownHTABTypes(): HtabEntryInfo[] {
 };
 
 export function getWellKnownSimpleHashTableTypes(): SimplehashEntryInfo[] {
-    const type = (prefix: string, elementType: string, canIterate = true) => ({
-        prefix, elementType, canIterate,
-    } as SimplehashEntryInfo);
+    const type = (prefix: string, type: string) => ({prefix, type});
 
     return [
         type('blockreftable', 'BlockRefTableEntry *'),
@@ -2163,16 +2161,17 @@ export function getWellKnownSimpleHashTableTypes(): SimplehashEntryInfo[] {
         /* 
          * These simple hash tables have iteration logic trimmed,
          * but leave it to show, that I hadn't forgotten it.
+         *
+         * type('backup_file', 'backup_file_entry *'),
+         * type('catalogid', 'CatalogIdMapEntry *'),
+         * type('collation_cache', 'collation_cache_entry *'),
+         * type('derives', 'ECDerivesEntry *'),
+         * type('keepwal', 'keepwal_entry *'),
+         * type('nsphash', 'SearchPathCacheEntry *'),
+         * type('pgstat_snapshot', 'PgStat_SnapshotEntry *'),
+         * type('rolename', 'RoleNameEntry *'),
+         * type('saophash', 'ScalarArrayOpExprHashEntry *'),
          */
-        type('backup_file', 'backup_file_entry *', false),
-        type('catalogid', 'CatalogIdMapEntry *', false),
-        type('collation_cache', 'collation_cache_entry *', false),
-        type('derives', 'ECDerivesEntry *', false),
-        type('keepwal', 'keepwal_entry *', false),
-        type('nsphash', 'SearchPathCacheEntry *', false),
-        type('pgstat_snapshot', 'PgStat_SnapshotEntry *', false),
-        type('rolename', 'RoleNameEntry *', false),
-        type('saophash', 'ScalarArrayOpExprHashEntry *', false),
     ];
 }
 

src/variables.ts

@@ -80,7 +80,7 @@ export interface ArraySpecialMemberInfo {
     /* Name of member which stores array */
     memberName: string;
     /* Expression to get length of array */
-    lengthExpr: string;
+    lengthExpression: string;
 }
 
 export interface ListPtrSpecialMemberInfo {
@@ -272,13 +272,7 @@ export interface SimplehashEntryInfo {
      * Type of element stored in this hash table.
      * Should be a pointer type, because no checks and adding pointer performed.
      */
-    elementType: string;
-
-    /* 
-     * Flag, indicating that 'start_iterate' and 'iterate' functions
-     * and 'iterator' struct exist.
-     */
-    canIterate: boolean;
+    type: string;
 }
 
 export class HashTableTypes {
@@ -3974,7 +3968,7 @@ export class ArraySpecialMember extends RealVariable {
          * invocation instead of simple member.
          */
         const parentExpr = `((${this.parent?.type})${this.parent?.getPointer()})`;
-        const lengthExpr = this.info.lengthExpr.replace(/{}/g, parentExpr);
+        const lengthExpr = this.info.lengthExpression.replace(/{}/g, parentExpr);
         if (lengthExpr.startsWith('!')) {
             return lengthExpr.substring(1);
         } else {
@@ -4952,7 +4946,7 @@ class SimplehashMember extends RealVariable {
     }
 
     get elementType(): string {
-        return this.entry.elementType;
+        return this.entry.type;
     }
 
     constructor(entry: SimplehashEntryInfo, args: RealVariableArgs) {
@@ -5052,6 +5046,16 @@ class SimplehashElementsMember extends Variable {
     private getIteratorType() {
         return this.iteratorType ??= `${this.hashTable.prefix}_iterator`;
     }
+    
+    private removeFromContext() {
+        /* 
+         * If we can not iterate over this simplehash, i.e. because of
+         * iteration function was trimmed from debug symbols, then we
+         * just remove ourselves from context, so we will not be handled
+         * further again.
+         */
+        this.context.hashTableTypes.simplehash.delete(this.hashTable.prefix);
+    }
 
     /* 
      * Allocate memory for iterator struct and invoke initialization function on it.
@@ -5068,7 +5072,7 @@ class SimplehashElementsMember extends Variable {
             iteratorPtr = await this.palloc(`sizeof(${iteratorType})`);
         } catch (error) {
             if (error instanceof EvaluationError) {
-                this.hashTable.entry.canIterate = false;
+                this.removeFromContext();
                 return undefined;
             }
             throw error;
@@ -5087,7 +5091,7 @@ class SimplehashElementsMember extends Variable {
             }
 
             await this.pfree(iteratorPtr);
-            this.hashTable.entry.canIterate = false;
+            this.removeFromContext();
             return undefined;
         }
 
@@ -5108,8 +5112,8 @@ class SimplehashElementsMember extends Variable {
             if (!(err instanceof EvaluationError)) {
                 throw err;
             }
-            
-            this.hashTable.entry.canIterate = false;
+
+            this.removeFromContext();
             return undefined;
         }