debounce the squiggles processing

Author: bobbrow

Extension/src/LanguageServer/configurations.ts

@@ -24,6 +24,7 @@ import { PersistentFolderState } from './persistentState';
 import { CppSettings, OtherSettings } from './settings';
 import { SettingsPanel } from './settingsPanel';
 import { ConfigurationType, getUI } from './ui';
+import { Deferral } from './utils';
 import escapeStringRegExp = require('escape-string-regexp');
 
 nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
@@ -279,13 +280,13 @@ export class CppProperties {
 
         vscode.workspace.onDidChangeTextDocument((e) => {
             if (e.document.uri.fsPath === settingsPath) {
-                void this.handleSquiggles().catch(logAndReturn.undefined);
+                this.handleSquiggles(e.document);
             }
         });
 
         vscode.workspace.onDidOpenTextDocument(document => {
             if (document.uri.fsPath === settingsPath) {
-                void this.handleSquiggles().catch(logAndReturn.undefined);
+                this.handleSquiggles(document);
             }
         });
 
@@ -352,7 +353,7 @@ export class CppProperties {
 
     private onSelectionChanged(): void {
         this.selectionChanged.fire(this.CurrentConfigurationIndex);
-        void this.handleSquiggles().catch(logAndReturn.undefined);
+        this.handleSquiggles();
     }
 
     private onCompileCommandsChanged(path: string): void {
@@ -1590,8 +1591,9 @@ export class CppProperties {
             if (firstParse) {
                 // Check documents that are already open since no event will fire for them.
                 const fsPath = this.propertiesFile.fsPath;
-                if (vscode.workspace.textDocuments.some(doc => doc.uri.fsPath === fsPath)) {
-                    void this.handleSquiggles().catch(logAndReturn.undefined);
+                const document = vscode.workspace.textDocuments.find(doc => doc.uri.fsPath === fsPath);
+                if (document) {
+                    this.handleSquiggles(document);
                 }
             }
         } catch (errJS) {
@@ -1859,7 +1861,22 @@ export class CppProperties {
         return errorMsg;
     }
 
-    private async handleSquiggles(): Promise<void> {
+    private lastConfigurationVersion: number = 0;
+    private handleSquigglesDeferral: Deferral | undefined;
+
+    private handleSquiggles(doc?: vscode.TextDocument): void {
+        // When the active config changes, we don't pass the doc in since the version would not have changed.
+        if (doc?.version !== this.lastConfigurationVersion) {
+            this.lastConfigurationVersion = doc?.version ?? 0;
+            this.handleSquigglesDeferral?.cancel();
+            this.handleSquigglesDeferral = new Deferral(() => void this.handleSquigglesImpl().catch(logAndReturn.undefined), 1000);
+        }
+    }
+
+    /**
+     * Not to be called directly. Use the `handleSquiggles` method instead which will debounce the calls.
+     */
+    private async handleSquigglesImpl(): Promise<void> {
         if (!this.propertiesFile) {
             return;
         }

Extension/src/LanguageServer/dataBinding.ts

@@ -3,23 +3,7 @@
  * See 'LICENSE' in the project root for license information.
  * ------------------------------------------------------------------------------------------ */
 import * as vscode from 'vscode';
-
-class Deferral {
-    private timer?: NodeJS.Timeout;
-
-    constructor(callback: () => void, timeout: number) {
-        this.timer = setTimeout(() => {
-            this.timer = undefined;
-            callback();
-        }, timeout);
-    }
-    public cancel() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = undefined;
-        }
-    }
-}
+import { Deferral } from './utils';
 
 export class DataBinding<T> {
     private valueChanged = new vscode.EventEmitter<T>();

Extension/src/LanguageServer/utils.ts

@@ -118,3 +118,23 @@ export async function checkDuration<T>(fn: () => Promise<T>): Promise<{ result:
     const result = await fn();
     return { result, duration: performance.now() - start };
 }
+
+/**
+ * A class that delays the execution of a callback until a specified timeout period has elapsed.
+ */
+export class Deferral {
+    private timer?: NodeJS.Timeout;
+
+    constructor(callback: () => void, timeout: number) {
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            callback();
+        }, timeout);
+    }
+    public cancel() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+}