perf: optimize configuration file update handling

Use dirty flag to detect changes in pgsql_hacker_helper.json and update
internal state lazily instead of constant parsing this file each time.

Author: ashenBlade

src/configuration.ts

@@ -3,6 +3,7 @@ import * as vscode from 'vscode';
 import * as vars from './variables';
 import * as utils from './utils';
 import { Log as logger } from './logger';
+import { Configuration } from './extension';
 
 export interface VariablesConfiguration {
     /* Array special members */
@@ -504,7 +505,7 @@ export function parseVariablesConfiguration(configFile: unknown): VariablesConfi
     }
 }
 
-export async function readConfigFile(file: vscode.Uri) {
+async function readConfigFile(file: vscode.Uri) {
     let document;
     try {
         document = await vscode.workspace.openTextDocument(file);
@@ -543,54 +544,52 @@ let formatterConfig: PgindentConfiguration | undefined;
 /* Flag indicating that configuration file should be refreshed */
 let configDirty = true;
 
-export function getVariablesConfiguration(): VariablesConfiguration | undefined {
-    return variablesConfig;
-}
-
-export function getFormatterConfiguration(): PgindentConfiguration | undefined {
-    return formatterConfig;
-}
-
-export async function refreshVariablesConfiguration(file: vscode.Uri) {
+async function checkConfigurationFresh() {
     if (!configDirty) {
         return;
     }
-
-    const config = await readConfigFile(file);
-    if (!config) {
-        return;
-    }
 
-    variablesConfig = parseVariablesConfiguration(config);
+    await refreshConfiguration();
     configDirty = false;
 }
 
-export async function refreshFormatterConfiguration(file: vscode.Uri) {
-    if (!configDirty) {
-        return;
-    }
-
-    const config = await readConfigFile(file);
-    if (!config) {
-        return;
-    }
+export async function getVariablesConfiguration() {
+    await checkConfigurationFresh();
+    return variablesConfig;
+}
 
-    formatterConfig = parseFormatterConfiguration(config);
-    configDirty = false;
+export async function getFormatterConfiguration() {
+    await checkConfigurationFresh();
+    return formatterConfig;
 }
 
-export async function refreshConfiguration(file: vscode.Uri) {
-    if (!configDirty) {
-        return;
-    }
+export async function refreshConfiguration() {
+    /* Do not check 'dirtyFlag', because this function must be invoked explicitly */
 
-    const config = await readConfigFile(file);
-    if (!config) {
+    if (!vscode.workspace.workspaceFolders?.length) {
         return;
     }
 
-    formatterConfig = parseFormatterConfiguration(config);
-    variablesConfig = parseVariablesConfiguration(config);
+    for (const folder of vscode.workspace.workspaceFolders) {
+        const file = Configuration.getConfigFile(folder.uri);
+        const config = await readConfigFile(file);
+        if (!config) {
+            return;
+        }
+
+        try {
+            formatterConfig = parseFormatterConfiguration(config);
+        } catch (err) {
+            logger.error('could not parse formatter configuration', err);
+        }
+        
+        try {
+            variablesConfig = parseVariablesConfiguration(config);
+        } catch (err) {
+            logger.error('could not parse variables configuration', err);
+        }
+    }
+    
     configDirty = false;
 }
 

src/extension.ts

@@ -4,7 +4,7 @@ import { Features } from './utils';
 import * as vars from './variables';
 import * as dbg from './debugger';
 import * as dap from './dap';
-import { refreshConfiguration, refreshVariablesConfiguration } from './configuration';
+import { markConfigFileDirty, refreshConfiguration } from './configuration';
 import { Log as logger } from './logger';
 import { setupPgConfSupport } from './pgconf';
 import { setupFormatting } from './formatter';
@@ -515,49 +515,16 @@ function setupPgVariablesView(context: vscode.ExtensionContext) {
     const pgvars = createPgVariablesView(context, nodeVars);
 
     setupNodeTagFiles(context, nodeVars);
-    
-    /* Refresh config files when debug session starts */
-    vscode.debug.onDidStartDebugSession(async _ => {
-        if (!vscode.workspace.workspaceFolders?.length) {
-            return;
-        }
-
-        for (const folder of vscode.workspace.workspaceFolders) {
-            logger.info('refreshing configuration files due to debug session start');
-            try {
-                const file = Configuration.getConfigFile(folder.uri);
-                await refreshVariablesConfiguration(file);
-            } catch (err: unknown) {
-                logger.error('could not refresh configuration in workspace %s', folder.uri.fsPath, err);
-            }
-        }
-    }, undefined, context.subscriptions);
 
     return pgvars;
 }
 
 function setupConfigurationFile(context: vscode.ExtensionContext) {
     /* Mark configuration dirty when user changes it - no eager parsing */
-    /*
-     * TODO: use dirty flag, instead of eager parsing
-     * const configFileWatcher = vscode.workspace.createFileSystemWatcher(Configuration.ExtensionSettingsFileName, false, false, true);
-     * context.subscriptions.push(configFileWatcher);
-     * configFileWatcher.onDidChange(() => markConfigFileDirty());
-     * configFileWatcher.onDidCreate(() => markConfigFileDirty());
-     */
-
-    /* Refresh config files when debug session starts */
-    vscode.debug.onDidStartDebugSession(async _ => {
-        if (!vscode.workspace.workspaceFolders?.length) {
-            return;
-        }
-
-        logger.info('refreshing configuration files due to debug session start');
-        for (const folder of vscode.workspace.workspaceFolders) {
-            const file = Configuration.getConfigFile(folder.uri);
-            await refreshVariablesConfiguration(file);
-        }
-    }, undefined, context.subscriptions);
+    const configFileWatcher = vscode.workspace.createFileSystemWatcher(Configuration.ExtensionSettingsFileName, false, false, true);
+    context.subscriptions.push(configFileWatcher);
+    configFileWatcher.onDidChange(markConfigFileDirty, undefined, context.subscriptions);
+    configFileWatcher.onDidCreate(markConfigFileDirty, undefined, context.subscriptions);
 }
 
 function registerCommands(context: vscode.ExtensionContext, pgvars: vars.PgVariablesViewProvider) {
@@ -611,18 +578,11 @@ function registerCommands(context: vscode.ExtensionContext, pgvars: vars.PgVaria
 
     /* Refresh config file command */
     const refreshConfigCmd = async () => {
-        if (!vscode.workspace.workspaceFolders?.length) {
-            return;
-        }
-        
         logger.info('refreshing config file due to command execution');
-        for (const folder of vscode.workspace.workspaceFolders) {
-            try {
-                const file = Configuration.getConfigFile(folder.uri);
-                await refreshConfiguration(file);
-            } catch (err: unknown) {
-                logger.error('could not refresh configuration in workspace %s', folder.uri.fsPath, err);
-            }
+        try {
+            await refreshConfiguration();
+        } catch (err: unknown) {
+            logger.error('could not refresh configuration', err);
         }
     };
 
@@ -761,6 +721,7 @@ function registerCommands(context: vscode.ExtensionContext, pgvars: vars.PgVaria
 
 async function setupNodeTagFiles(context: vscode.ExtensionContext,
                                  nodeVars: vars.NodeVarRegistry) {
+    /* TODO: remove this thing with setting */
     const getNodeTagFiles = () => {
         /* TODO: remove this setting */
         const customNodeTagFiles = Configuration.getCustomNodeTagFiles();

src/formatter.ts

@@ -4,9 +4,8 @@ import * as utils from './utils';
 import { Log as logger } from './logger';
 import { getWellKnownBuiltinContribs } from './constants';
 import { Configuration } from './extension';
-import { parseFormatterConfiguration, 
-         PgindentConfiguration, 
-         readConfigFile } from './configuration';
+import { getFormatterConfiguration,
+         PgindentConfiguration } from './configuration';
 import { PghhError } from './error';
 import * as path from 'path';
 import * as os from 'os';
@@ -237,17 +236,7 @@ class PgindentDocumentFormatterProvider implements vscode.DocumentFormattingEdit
     }
 
     private async getTypedefsFromConfiguration(workspace: vscode.WorkspaceFolder) {
-        const file = Configuration.getConfigFile(workspace.uri);
-        if (!await utils.fileExists(file)) {
-            return [];
-        }
-
-        const configObj = await readConfigFile(file);
-        if (!configObj) {
-            return [];
-        }
-
-        const config = parseFormatterConfiguration(configObj);
+        const config = await getFormatterConfiguration();
         if (!config?.typedefs?.length) {
             return [];
         }

src/variables.ts

@@ -5433,7 +5433,7 @@ export class PgVariablesViewProvider implements vscode.TreeDataProvider<Variable
     }
 
     async initializeExecContextFromConfig(context: ExecContext) {
-        const config = getVariablesConfiguration();
+        const config = await getVariablesConfiguration();
         if (!config) {
             return;
         }