Merge branch 'main' of https://github.com/microsoft/vscode-cpptools into dev/coleng/editorconfig_sections

Author: Colengms

Extension/src/LanguageServer/client.ts

@@ -1285,6 +1285,12 @@ export class DefaultClient implements Client {
 
                 // Listen for messages from the language server.
                 this.registerNotifications();
+
+                // If a file is already open when we activate, sometimes we don't get any notifications about visible
+                // or active text editors, visible ranges, or text selection. As a workaround, we trigger
+                // onDidChangeVisibleTextEditors here.
+                const cppEditors: vscode.TextEditor[] = vscode.window.visibleTextEditors.filter(e => util.isCpp(e.document));
+                await this.onDidChangeVisibleTextEditors(cppEditors);
             }
 
             // update all client configurations

Extension/src/LanguageServer/configurations.ts

@@ -138,7 +138,7 @@ export class CppProperties {
     private configFileWatcherFallbackTime: Date = new Date(); // Used when file watching fails.
     private compileCommandsFile: vscode.Uri | undefined | null = undefined;
     private compileCommandsFileWatchers: fs.FSWatcher[] = [];
-    private compileCommandsFileWatcherFallbackTime: Date = new Date(); // Used when file watching fails.
+    private compileCommandsFileWatcherFallbackTime: Map<string, Date> = new Map<string, Date>(); // Used when file watching fails.
     private defaultCompilerPath: string | null = null;
     private knownCompilers?: KnownCompiler[];
     private defaultCStandard: string | null = null;
@@ -1093,6 +1093,10 @@ export class CppProperties {
 
             if (configuration.compileCommands) {
                 configuration.compileCommands = this.resolvePath(configuration.compileCommands);
+                if (!this.compileCommandsFileWatcherFallbackTime.has(configuration.compileCommands)) {
+                    // Start tracking the fallback time for a new path.
+                    this.compileCommandsFileWatcherFallbackTime.set(configuration.compileCommands, new Date());
+                }
             }
 
             if (configuration.forcedInclude) {
@@ -1104,12 +1108,31 @@ export class CppProperties {
             }
         }
 
+        this.clearStaleCompileCommandsFileWatcherFallbackTimes();
         this.updateCompileCommandsFileWatchers();
         if (!this.configurationIncomplete) {
             this.onConfigurationsChanged();
         }
     }
 
+    private clearStaleCompileCommandsFileWatcherFallbackTimes(): void {
+        // We need to keep track of relevant timestamps, so we cannot simply clear all entries.
+        // Instead, we clear entries that are no longer relevant.
+        const trackedCompileCommandsPaths: Set<string> = new Set();
+        this.configurationJson?.configurations.forEach((config: Configuration) => {
+            const path = this.resolvePath(config.compileCommands);
+            if (path.length > 0) {
+                trackedCompileCommandsPaths.add(path);
+            }
+        });
+
+        for (const path of this.compileCommandsFileWatcherFallbackTime.keys()) {
+            if (!trackedCompileCommandsPaths.has(path)) {
+                this.compileCommandsFileWatcherFallbackTime.delete(path);
+            }
+        }
+    }
+
     private compileCommandsFileWatcherTimer?: NodeJS.Timeout;
     private compileCommandsFileWatcherFiles: Set<string> = new Set<string>();
 
@@ -2310,14 +2333,18 @@ export class CppProperties {
         fs.stat(compileCommandsFile, (err, stats) => {
             if (err) {
                 if (err.code === "ENOENT" && this.compileCommandsFile) {
+                    this.compileCommandsFileWatchers.forEach((watcher: fs.FSWatcher) => watcher.close());
                     this.compileCommandsFileWatchers = []; // reset file watchers
                     this.onCompileCommandsChanged(compileCommandsFile);
                     this.compileCommandsFile = null; // File deleted
                 }
-            } else if (stats.mtime > this.compileCommandsFileWatcherFallbackTime) {
-                this.compileCommandsFileWatcherFallbackTime = new Date();
-                this.onCompileCommandsChanged(compileCommandsFile);
-                this.compileCommandsFile = vscode.Uri.file(compileCommandsFile); // File created.
+            } else {
+                const compileCommandsLastChanged: Date | undefined = this.compileCommandsFileWatcherFallbackTime.get(compileCommandsFile);
+                if (compileCommandsLastChanged !== undefined && stats.mtime > compileCommandsLastChanged) {
+                    this.compileCommandsFileWatcherFallbackTime.set(compileCommandsFile, new Date());
+                    this.onCompileCommandsChanged(compileCommandsFile);
+                    this.compileCommandsFile = vscode.Uri.file(compileCommandsFile); // File created.
+                }
             }
         });
     }

Extension/src/LanguageServer/protocolFilter.ts

@@ -8,16 +8,13 @@ import * as path from 'path';
 import * as vscode from 'vscode';
 import { Middleware } from 'vscode-languageclient';
 import * as util from '../common';
-import { logAndReturn } from '../Utility/Async/returns';
 import { Client } from './client';
 import { clients } from './extension';
 import { shouldChangeFromCToCpp } from './utils';
 
 export const RequestCancelled: number = -32800;
 export const ServerCancelled: number = -32802;
 
-let anyFileOpened: boolean = false;
-
 export function createProtocolFilter(): Middleware {
     return {
         didOpen: async (document, sendMessage) => {
@@ -43,16 +40,7 @@ export function createProtocolFilter(): Middleware {
                     // client.takeOwnership() will call client.TrackedDocuments.add() again, but that's ok. It's a Set.
                     client.onDidOpenTextDocument(document);
                     client.takeOwnership(document);
-                    void sendMessage(document).then(() => {
-                        // For a file already open when we activate, sometimes we don't get any notifications about visible
-                        // or active text editors, visible ranges, or text selection. As a workaround, we trigger
-                        // onDidChangeVisibleTextEditors here, only for the first file opened.
-                        if (!anyFileOpened) {
-                            anyFileOpened = true;
-                            const cppEditors: vscode.TextEditor[] = vscode.window.visibleTextEditors.filter(e => util.isCpp(e.document));
-                            client.onDidChangeVisibleTextEditors(cppEditors).catch(logAndReturn.undefined);
-                        }
-                    });
+                    void sendMessage(document);
                 }
             }
         },