chore: remove using cached typedefs.list file

ashenBlade · ashenBlade · commit b067f46be99b · 2025-09-14T23:22:36.000+03:00
If we maintain our own typedefs.list file, then we should constantly
monitor its relevance, but such code will become too messy and complex.
Instead of setting listeners on file changes we just do not use our own
typedefs.list file.
Now, each file specified in 'typedefs' configuration parameter will be
just passed to pgindent and it will create it's own temp copy. Actually,
the fact that pgindent created new temp copies each time was the main
reason to copy it's logic, but now it becomes more clear that this is
more pragratic way. Anyway, it's not that performance critical.
diff --git a/docs/config_file.md b/docs/config_file.md
@@ -135,18 +135,13 @@ Example:
 
 ### Custom `typedefs.list` files
 
-`typedefs.list` file is required for correct `pg_bsd_indent` work. It contains list of types that treated by formatter differently. Usually, it does not change, but sometimes you may want to change it manually. i.e. when creating new patches or writing contribs with `typedef` types.
+`typedefs.list` file is required for correct `pg_bsd_indent` work. It contains list of types that treated by formatter differently. During extension development you may want to create your own `typedefs.list` for your extension to later pass it to `./pgindent --list-of-typedefs=my.custom.typedefs.list`.
 
-Extension creates it's own copy of `typedefs.list` in `.vscode` directory (`.vscode/pg-hacker-helper.typedefs.list`):
-
-1. Take builtin `src/tools/pgindent/typedefs.list` file
-2. Add all custom `typedefs.list` files from `typedefs` setting
-3. Store into `.vscode/pg-hacker-helper.typedefs.list` file
-
-After that this file will be used for all formattings.
+You can specify your custom `typedefs.list` files in configuration using `typedefs` setting.
 
 > If `pg_bsd_indent` is not available extension will try to build it.
-> For this `pg_config` is required, but if it is missing, then extension will ask you to enter path to it manually.
+> It will perform all necessary work: building, patching, downloading (if necessary).
+> To build old versions `pg_config` is required - it will be searched in `./src`, but if it missing will ask you to enter path to it manually.
 
 `typedefs` setting can be either plain string or array of strings - each string is a path which can be in 2 forms:
 
@@ -167,7 +162,7 @@ Read global typedefs file stored in temporary directory.
 
 ```json
 {
-    "typedefs": "/tmp/cached.custom.typedefs.list"
+    "typedefs": "/tmp/custom.typedefs.list"
 }
 ```
 
diff --git a/src/extension.ts b/src/extension.ts
@@ -5,7 +5,7 @@ import * as vars from './variables';
 import * as constants from './constants';
 import * as dbg from './debugger';
 import * as dap from './dap';
-import path from 'path';
+import { FormatterConfiguration, PgindentConfiguration } from './formatter';
 
 
 function createDebuggerFacade(type: string, provider: NodePreviewTreeViewProvider): dbg.GenericDebuggerFacade | undefined {
@@ -40,7 +40,7 @@ export class NodePreviewTreeViewProvider implements vscode.TreeDataProvider<vars
      * Representation of parsed configuration file.
      * Used to seed ExecContext during initialization.
      */
-    configFile?: ConfigFile;
+    configFile?: VariablesConfiguration;
 
     /**
      * ExecContext used to pass to all members.
@@ -401,13 +401,11 @@ export async function dumpVariableToDocumentCommand(variable: dap.DebugVariable,
     vscode.window.showTextDocument(document);
 }
 
-export class ConfigFile {
+interface VariablesConfiguration {
     /* Array special members */
     arrayInfos?: vars.ArraySpecialMemberInfo[];
     /* Information about type aliases */
     aliasInfos?: vars.AliasInfo[];
-    /* Path to custom typedef's file */
-    typedefs?: string[];
     /* Custom List types */
     customListTypes?: vars.ListPtrSpecialMemberInfo[];   
     /* Types stored in HTABs */
@@ -418,6 +416,11 @@ export class ConfigFile {
     bitmaskEnumMembers?: vars.BitmaskMemberInfo[];
 }
 
+class ConfigFile {
+    variables?: VariablesConfiguration;
+    formatter?: PgindentConfiguration;
+}
+
 function parseConfigurationFile(configFile: any): ConfigFile | undefined {
     const parseArrayMember = (obj: any): vars.ArraySpecialMemberInfo | undefined => {
         if (!(obj && typeof obj === 'object' && obj !== null)) {
@@ -825,20 +828,38 @@ function parseConfigurationFile(configFile: any): ConfigFile | undefined {
                 ? configFile.aliases.map(parseSingleAlias).filter((a: any) => a !== undefined)
                 : undefined;
 
-    const typedefs = parseTypedefs(configFile.typedefs);
     const customListTypes = parseListTypes(configFile.customListTypes);
     const htabTypes = parseHtabTypes(configFile.htab);
     const simpleHashTableTypes = parseSimplehashTypes(configFile.simplehash);   
     const bitmaskEnumMembers = parseEnumBitmasks(configFile.enums);
+    const typedefs = parseTypedefs(configFile.typedefs);
+
+    let variables = undefined;
+    if (   arrayInfos?.length
+        || aliasInfos?.length
+        || customListTypes?.length
+        || htabTypes?.length
+        || simpleHashTableTypes?.length
+        || bitmaskEnumMembers?.length) {
+        variables = {
+            arrayInfos,
+            aliasInfos,
+            customListTypes,
+            htabTypes,
+            simpleHashTableTypes,
+            bitmaskEnumMembers,
+        }
+    }
+    let formatter = undefined;
+    if (typedefs?.length) {
+        formatter = {
+            typedefs,
+        }
+    }
 
     return {
-        arrayInfos,
-        aliasInfos,
-        typedefs,
-        customListTypes,
-        htabTypes,
-        simpleHashTableTypes,
-        bitmaskEnumMembers,
+        variables,
+        formatter,
     }
 }
 
@@ -1156,38 +1177,12 @@ export function setupExtension(context: vscode.ExtensionContext,
             return;
         }
         
-        if (parsedConfigFile) {
-            nodesView.configFile = parsedConfigFile;
+        if (parsedConfigFile?.variables) {
+            nodesView.configFile = parsedConfigFile.variables;
         }
-        
-        if (parsedConfigFile?.typedefs?.length) {
-            const typedefs = [];
-            for (const typedef of parsedConfigFile.typedefs) {
-                let p;
-                if (path.isAbsolute(typedef)) {
-                    p = vscode.Uri.file(typedef);
-                } else {
-                    const workspace = vscode.workspace.workspaceFolders?.length
-                                ? vscode.workspace.workspaceFolders[0]
-                                : undefined;
-                    if (!workspace) {
-                        logger.warn('could not determine workspace for file %s to add typedef file', typedef);
-                        continue;
-                    }
 
-                    p = utils.joinPath(workspace.uri, typedef);
-                }
-
-                if (await utils.fileExists(p)) {
-                    typedefs.push(p);
-                } else {
-                    logger.warn('typedef file %s does not exist', p.fsPath);
-                }
-            }
-
-            if (typedefs.length) {
-                Configuration.CustomTypedefsFiles = typedefs;
-            }
+        if (parsedConfigFile?.formatter) {
+            FormatterConfiguration.typedefs = parsedConfigFile.formatter.typedefs;
         }
     }
 
@@ -1550,9 +1545,6 @@ export class Configuration {
     };
     static ExtensionSettingsFileName = 'pgsql_hacker_helper.json';
 
-    /* Paths to custom typedefs.list files in pgsql_hacker_helper.json file */
-    static CustomTypedefsFiles: vscode.Uri[] | undefined = undefined;
-
     static getLogLevel() {
         return this.getConfig<string>(this.ConfigSections.LogLevel);
     };
diff --git a/src/formatter.ts b/src/formatter.ts
@@ -23,19 +23,14 @@ function findSuitableWorkspace(document: vscode.TextDocument) {
     return vscode.workspace.workspaceFolders[0];
 }
 
-export const typedefFile = 'pg-hacker-helper.typedefs.list';
+export interface PgindentConfiguration {
+    typedefs?: string[];
+}
+export const FormatterConfiguration: PgindentConfiguration = {}
 
 class PgindentDocumentFormatterProvider implements vscode.DocumentFormattingEditProvider {
-    /* Flags found in pgindent */
-    static pg_bsd_indentDefaultFlags = [
-        '-bad', '-bap', '-bbb', '-bc', '-bl', '-cli1', '-cp33', '-cdb', 
-        '-nce', '-d0', '-di12', '-nfc1', '-i4', '-l79', '-lp', '-lpl', 
-        '-nip', '-npro', '-sac', '-tpg', '-ts4'
-    ];
-
     private savedPgindentPath?: vscode.Uri;
     private savedPgbsdPath?: vscode.Uri;
-    private savedProcessedTypedef?: vscode.Uri;
     constructor(private logger: utils.ILogger) {}
 
     private async getPgConfigPath(workspace: vscode.WorkspaceFolder) {
@@ -236,28 +231,6 @@ class PgindentDocumentFormatterProvider implements vscode.DocumentFormattingEdit
         return pgBsdIndent;
     }
 
-    private getProcessedTypedefFilePath(workspace: vscode.WorkspaceFolder) {
-        /* 
-         * Formatter module supports custom typedef.lists which are added
-         * to builtin in 'src/tools/pgindent'.  But formatter tool does not
-         * allow specifying list of typedef.lists, so I have to merge all
-         * files and for performance reasons this file is cached.
-         * 
-         * Currently, it's located in '/tmp/pg-hacker-helper.typedefs.list'.
-         * 
-         * XXX: when you are working with multiple pg versions you may have
-         *      different set of custom typedef.lists, so this can mess
-         *      everything up, so it would be more nice to store it i.e. in
-         *      '.vscode' directory.
-         *
-         * XXX: if you change location - do not forget to update try/catch block
-         *      where file is saved (catch block creates .vscode directory and
-         *      perform second attempt to save file).
-         */
-
-        return utils.joinPath(workspace.uri, '.vscode', typedefFile);
-    }
-
     private async saveCachedTypedefFile(content: string, typedefsFile: vscode.Uri,
                                         workspace: vscode.WorkspaceFolder) {
         /*
@@ -287,72 +260,30 @@ class PgindentDocumentFormatterProvider implements vscode.DocumentFormattingEdit
         await utils.writeFile(typedefsFile, content);
     }
 
-    private async enrichTypedefs(typedefs: Set<string>) {
-        const customTypedefFiles = Configuration.CustomTypedefsFiles;
-        if (!customTypedefFiles || customTypedefFiles.length === 0) {
-            return;
+    private async getListOfTypedefs(workspace: vscode.WorkspaceFolder) {
+        const files = FormatterConfiguration.typedefs;
+        if (!files?.length) {
+            return '';
         }
 
-        for (const typedef of customTypedefFiles) {
-            let content;
-            try {
-                content = await utils.readFile(typedef);
-            } catch (err) {
-                this.logger.warn('failed to read custom typedefs.list file %s', typedef.fsPath);
-                continue;
+        const typedefs = [];
+        for (const f of files) {
+            let typedefFile;
+            if (path.isAbsolute(f)) {
+                typedefFile = vscode.Uri.file(f);
+            } else {
+                typedefFile = utils.getWorkspacePgSrcFile(workspace.uri, f);
             }
-
-            content.split('\n').forEach(x => typedefs.add(x.trim()));
-        }
-    }
-
-    private async getProcessedTypedefs(workspace: vscode.WorkspaceFolder) {
-        if (this.savedProcessedTypedef) {
-            if (await utils.fileExists(this.savedProcessedTypedef)) {
-                return this.savedProcessedTypedef;
+            
+            if (!await utils.fileExists(typedefFile)) {
+                this.logger.warn('could not find file %s', typedefFile);
+                continue;
             }
-
-            this.savedProcessedTypedef = undefined;
-        }
-
-        const processedTypedef = this.getProcessedTypedefFilePath(workspace);
-        if (await utils.fileExists(processedTypedef)) {
-            /* 
-             * This file is cache in /tmp, so may be created from another
-             * workspace which can have different content - delete it
-             * to prevent formatting errors.
-             */
-            this.logger.info('found existing typedefs.list in .vscode directory');
-            this.savedProcessedTypedef = processedTypedef;
-            return processedTypedef;
+            
+            typedefs.push(`--typedefs=${typedefFile.fsPath}`);
         }
 
-        /* 
-         * Add and remove some entries from `typedefs.list` file
-         * downloaded from buildfarm.
-         * 
-         * This data did not change since PG 10 and i don't think
-         * it will change in near future.
-         */
-        const rawTypedefs = await this.getDefaultTypedefs(workspace);
-        const entries = new Set(rawTypedefs.split('\n'));
-
-        [
-            'ANY', 'FD_SET', 'U', 'abs', 'allocfunc', 'boolean', 'date',
-            'digit', 'ilist', 'interval', 'iterator', 'other', 'pointer',
-            'printfunc', 'reference', 'string', 'timestamp', 'type', 'wrap'
-        ].forEach(e => entries.delete(e));
-        entries.add('bool');
-        entries.delete('');
-        await this.enrichTypedefs(entries);
-
-        const arr = Array.from(entries.values());
-        arr.sort();
-
-        await this.saveCachedTypedefFile(arr.join('\n'), processedTypedef, workspace);
-
-        this.savedProcessedTypedef = processedTypedef;
-        return processedTypedef;
+        return typedefs;
     }
 
     private async getPgBsdIndent(workspace: vscode.WorkspaceFolder, pgindent: vscode.Uri) {
@@ -394,22 +325,18 @@ class PgindentDocumentFormatterProvider implements vscode.DocumentFormattingEdit
                                       pg_bsd_indent: vscode.Uri,
                                       pgindent: vscode.Uri,
                                       workspace: vscode.WorkspaceFolder) {
-        /* 
-         * We use pg_bsd_indent directly instead of pgindent because:
-         *  - different pgindent versions behaves differently
-         *  - direct call to pg_bsd_indent is faster
-         *  - pgindent creates temp files which are not removed if error
-         *    happens - we can not track these files (main reason)
-         */
-        const typedefs = await this.getProcessedTypedefs(workspace);
+        const typedefs = await this.getListOfTypedefs(workspace);
+
+        /* Work in pgindent dir, so it can find default typedefs.list */
+        const cwd = path.resolve(pgindent.fsPath, '..');
         try {
             await utils.execShell(
                 pgindent.fsPath, [
+                    ...typedefs,
                     `--indent=${pg_bsd_indent.fsPath}`,
-                    `--typedefs=${typedefs.fsPath}`,
                     document.fsPath,
                 ],
-                {cwd: utils.getWorkspacePgSrcFile(workspace.uri).fsPath},
+                {cwd},
             );
         } catch (err) {
             if (!(err instanceof utils.ShellExecError)) {
diff --git a/src/test/suite/formatting.test.ts b/src/test/suite/formatting.test.ts
@@ -1,7 +1,6 @@
 import * as assert from 'assert';
 import * as vscode from 'vscode';
 import { getTestEnv, TestEnv } from './env';
-import {typedefFile} from '../../formatter';
 import * as utils from '../../utils';
 import * as fs from 'fs';
 import path from 'path';
@@ -33,15 +32,7 @@ suite('Formatting', async function () {
                 /* skip */
             }
         }
-        
-        /* Remove compiled typedef.list file after previous run */
-        await swallow(async () => {
-            const typedef = env.getWorkspaceFile('.vscode', typedefFile);
-            fs.rmSync(typedef, {
-                force: true,
-            });
-        });
-        
+
         /* Remove cloned pg_bsd_indent */
         await swallow(async () => {
             const pgBsdIndentDir = 
