feat: add maxContainerLength setting to limit length of container types

This is a vscode setting that stores max length of shown elements in container
types: list, array, hash table, bitmapset, etc...

But this does not prevent getting elements - just stop iteration after
reaching this limit, so default value is set to 128 - too much for human
to think about.

Author: ashenBlade

docs/configuration.md

@@ -4,7 +4,7 @@ Extension has multiple settings to customize different aspects.
 
 ## VS Code settings
 
-There are 3 settings:
+There are 4 settings:
 
 - `postgresql-hacker-helper.logLevel` - minimum log level (for old VS Code up to 1.74.0).
 
@@ -25,6 +25,13 @@ There are 3 settings:
   - If not specified, it will be searched in `*srcPath*/src/tools` directory.
   - If specified, and failed to run extension will try to build it.
 
+- `postgresql-hacker-helper.maxContainerLength` - max length of elements shown in container types: `List`, arrays, `Bitmapset`, hash tables, etc...
+
+  How many elements must be shown in elements of container type.
+  This setting must prevent using garbage stored in fields.
+  
+  Default: `128`
+
 ## Configuration file
 
 Extension has config file with custom settings - `.vscode/pgsql_hacker_helper.json`.

package.json

@@ -209,6 +209,13 @@
                     "title": "Path to root of PostgreSQL source files",
                     "type": "string",
                     "description": "Path to source files of PostgreSQL. Set it if you have sources in separate sub-directory from root of project.\nIf not set search will start in project root directory"
+                },
+                "postgresql-hacker-helper.maxContainerLength": {
+                    "title": "Max length to show in container types",
+                    "type": "integer",
+                    "default": 128,
+                    "minimum": 1,
+                    "description": "Max length of elements to show in PG variables view. Applies to container types: List, arrays, Bitmapset, HTAB, simplehash, etc..."
                 }
             }
         },

src/configuration.ts

@@ -778,6 +778,7 @@ export class VsCodeSettings {
         LogLevel: 'logLevel',
         PgbsdindentPath: 'pg_bsd_indentPath',
         SrcPath: 'srcPath',
+        MaxContainerLength: 'maxContainerLength',
     };
 
     static logLevel: string | undefined;
@@ -801,6 +802,12 @@ export class VsCodeSettings {
         return this.srcPath ??= this.getConfig<string>(this.ConfigSections.SrcPath);
     }
 
+    static maxContainerLength: number | undefined;
+    static getMaxContainerLength() {
+        /* 128 - default value specified in package.json */
+        return this.maxContainerLength ??= (this.getConfig<number>(this.ConfigSections.MaxContainerLength) ?? 128);
+    }
+
     static getConfig<T>(section: string) {
         const topLevelSection = this.ConfigSections.TopLevelSection;
         const config = vscode.workspace.getConfiguration(topLevelSection);
@@ -816,6 +823,7 @@ export class VsCodeSettings {
         this.srcPath = this.getConfig<string>(this.ConfigSections.SrcPath);
         this.customPgBsdIndentPath = this.getConfig<string>(this.ConfigSections.PgbsdindentPath);
         this.customNodeTagFiles = this.getConfig<string[]>(this.ConfigSections.NodeTagFiles);
+        this.maxContainerLength = this.getConfig<number>(this.ConfigSections.MaxContainerLength);
     }
 }
 

src/variables.ts

@@ -4,7 +4,7 @@ import * as constants from './constants';
 import * as dbg from './debugger';
 import { Log as logger } from './logger';
 import { PghhError, EvaluationError, unnullify } from './error';
-import { Configuration } from './configuration';
+import { Configuration, VsCodeSettings } from './configuration';
 
 export interface AliasInfo {
     /* Declared type */
@@ -579,6 +579,15 @@ export class ExecContext {
     }
 }
 
+function clampContainerLength(size: number) {
+    const max = VsCodeSettings.getMaxContainerLength();
+    return max < size ? max : size;
+}
+
+function getMaxContainerLength() {
+    return VsCodeSettings.getMaxContainerLength();
+}
+
 /**
  * Special value for frameId used by ephemeral variables:
  * they do not need to evaluate anything.
@@ -3897,8 +3906,8 @@ export class ListNodeVariable extends NodeVariable {
             logger.warn('failed to obtain list size for %s', this.name);
             return;
         }
-        /* TODO: add size check */
-        return length;
+        
+        return clampContainerLength(length);
     }
 
     async getListElements() {
@@ -3921,12 +3930,6 @@ export class ListNodeVariable extends NodeVariable {
 
 
 export class ArraySpecialMember extends RealVariable {
-    /**
-     * Prevent errors/bugs if there was garbage after
-     * length expression evaluation.
-     */
-    static plausibleMaxLength = 1024;
-    
     /**
      * Expression to evaluate to obtain array length.
      * Appended to target struct from right.
@@ -4000,9 +4003,7 @@ export class ArraySpecialMember extends RealVariable {
         }
 
         /* Yes, we may have garbage, but what if the array is that huge? */
-        if (ArraySpecialMember.plausibleMaxLength < length) {
-            length = ArraySpecialMember.plausibleMaxLength;
-        }
+        length = clampContainerLength(length);
 
         const parent = unnullify(this.parent, 'this.parent');
         const memberExpr = `((${parent.type})${parent.getPointer()})->${this.info.memberName}`;
@@ -4063,11 +4064,14 @@ class BitmapSetSpecialMember extends NodeVariable {
         }
 
         const n = Number(nwords.value);
+
         /* 
-         * For 64-bit system even 20 is large number: 10 * 64 = 640.
-         * Human will not be able to handle such amount of data.
+         * For 64-bit system even 50 is large number: 50 * 64 = 3200.
+         * But actually this is *potential* size, so can we allow such
+         * large value - in reality it can contain only 1 element, just
+         * in last word, but this acts like a pretty good correctness check.
          */
-        const maxNWords = 10;
+        const maxNWords = 50;
         if (Number.isNaN(n) || maxNWords <= n) {
             return false;
         }
@@ -4165,6 +4169,7 @@ class BitmapSetSpecialMember extends NodeVariable {
 
         let number = -1;
         const numbers = [];
+        const maxLength = getMaxContainerLength();
         do {
             const expression = `bms_next_member((Bitmapset *)${this.getPointer()}, ${number})`;
             try {
@@ -4188,7 +4193,7 @@ class BitmapSetSpecialMember extends NodeVariable {
             }
 
             numbers.push(number);
-        } while (number >= 0);
+        } while (number >= 0 && numbers.length < maxLength);
 
         return numbers;
     }
@@ -4216,6 +4221,7 @@ class BitmapSetSpecialMember extends NodeVariable {
         }
 
         const expression = `bms_first_member((Bitmapset *)${e.result})`;
+        const maxLength = getMaxContainerLength();
         let number = -1;
         const numbers = [];
         do {
@@ -4232,7 +4238,7 @@ class BitmapSetSpecialMember extends NodeVariable {
             }
 
             numbers.push(number);
-        } while (number >= 0);
+        } while (number >= 0 && numbers.length < maxLength);
 
         await this.pfree(e.result);
 
@@ -4843,7 +4849,6 @@ class HTABElementsMember extends Variable {
          */
         try {
             await this.evaluateVoid(`hash_seq_term((HASH_SEQ_STATUS *)${hashSeqStatus})`);
-
         } catch (err) {
             if (!(err instanceof EvaluationError)) {
                 throw err;
@@ -4879,6 +4884,7 @@ class HTABElementsMember extends Variable {
             return;
         }
 
+        const maxLength = getMaxContainerLength();
         let entry;
         while ((entry = await this.getNextHashEntry(hashSeqStatus))) {
             let result;
@@ -4897,13 +4903,14 @@ class HTABElementsMember extends Variable {
                 return undefined;
             }
 
+            let variable;
             try {
-                const variable = await Variable.create({
+                variable = await Variable.create({
                     ...result,
-                    name: `${variables.length}`,
+                    name: `[${variables.length}]`,
                     value: result.result,
+                    memoryReference: result.memoryReference,
                 }, this.frameId, this.context, this);
-                variables.push(variable);
             } catch (error) {
                 if (error instanceof EvaluationError) {
                     await this.finalizeHashSeqStatus(hashSeqStatus);
@@ -4912,6 +4919,16 @@ class HTABElementsMember extends Variable {
 
                 throw error;
             }
+
+            variables.push(variable);
+            if (maxLength < variables.length) {
+                /* 
+                 * If we terminate iteration before iteration is completed,
+                 * we have to call finalizer function
+                 */
+                await this.finalizeHashSeqStatus(hashSeqStatus);
+                break;
+            }
         }
 
         await this.pfree(hashSeqStatus);
@@ -5008,15 +5025,16 @@ class SimplehashElementsMember extends Variable {
               hashTable);
         this.hashTable = hashTable;
     }
+    
+    protected async getDescription() {
+        return '';
+    }
 
-    async getTreeItem(): Promise<vscode.TreeItem> {
-        /* Show only '$elements$' */
-        return {
-            label: '$elements$',
-            collapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
-        };
+    protected isExpandable() {
+        return true;
     }
 
+    /* TODO: no need to cache these */
     /* 
      * Cached identifier names for function and types
      */
@@ -5087,7 +5105,7 @@ class SimplehashElementsMember extends Variable {
         return iteratorPtr;
     }
 
-    async iterate(iterator: string, current: number) {
+    async iterate(iterator: string, index: number) {
         const iterFunction = this.getIteratorFunction();
         const hashTableType = `(${this.getHashTableType()} *) ${this.hashTable.getPointer()}`;
         const iteratorArg = `(${this.getIteratorType()} *) ${iterator}`;
@@ -5113,8 +5131,9 @@ class SimplehashElementsMember extends Variable {
         try {
             return await Variable.create({
                 ...result,
-                name: `${current}`,
+                name: `[${index}]`,
                 value: result.result,
+                memoryReference: result.memoryReference,
             }, this.frameId, this.context, this);
         } catch (err) {
             if (!(err instanceof EvaluationError)) {
@@ -5149,10 +5168,12 @@ class SimplehashElementsMember extends Variable {
             return;
         }
 
+        const maxLength = getMaxContainerLength();
         const variables = [];
         let id = 0;
         let variable;
-        while ((variable = await this.iterate(iterator, id))) {
+        while (   variables.length < maxLength 
+               && (variable = await this.iterate(iterator, id))) {
             ++id;
             variables.push(variable);
         }
@@ -5179,7 +5200,7 @@ class FlagsMemberVariable extends RealVariable {
      * debug symbols (i.e. for gdb use '-g3' level).
      * 
      * But even if we know numeric value of enum member and have the same
-     * endianess we still have to evaluate all expressions in debugger, because
+     * endianness we still have to evaluate all expressions in debugger, because
      * 1) due to another major pg version numeric values can change
      * 2) we can debug coredump collected from another machine, so we should not
      *    assume this PC is binary compatible with one that is debugged