close file watchers on renames for linux based machines, add the force flag for failed providers

Author: yiftahw

Extension/src/LanguageServer/client.ts

@@ -2039,9 +2039,9 @@ export class DefaultClient implements Client {
         const provideConfigurationAsync: () => Thenable<SourceFileConfigurationItem[] | undefined> = async () => {
             try {
                 if (!await provider.canProvideConfiguration(docUri, tokenSource.token)) {
-                    const forceCheck: boolean = true;
-                    this.configuration.checkCompileCommands(forceCheck);
-                    console.log("provideCustomConfigurationAsync(): Provider cannot provide configuration for: ", docUri.path);
+                    // some file cannot be provided by this provider
+                    // e.g file not included in a CMake project
+                    this.configuration.configurationProviderFailed();
                     return [];
                 }
             } catch (err) {

Extension/src/LanguageServer/configurations.ts

@@ -136,9 +136,10 @@ export class CppProperties {
     private currentConfigurationIndex: PersistentFolderState<number> | undefined;
     private configFileWatcher: vscode.FileSystemWatcher | null = null;
     private configFileWatcherFallbackTime: Date = new Date(); // Used when file watching fails.
-    private compileCommandsFile: vscode.Uri | undefined | null = undefined;
+    private compileCommandsFile: string | undefined = undefined;
     private compileCommandsFileWatcher: fs.FSWatcher | undefined = undefined;
     private compileCommandsFileWatcherFallbackTime: Date = new Date(); // Used when file watching fails.
+    private configurationProviderFailedToProvide: boolean = false;
     private defaultCompilerPath: string | null = null;
     private knownCompilers?: KnownCompiler[];
     private defaultCStandard: string | null = null;
@@ -319,8 +320,7 @@ export class CppProperties {
         void this.handleSquiggles().catch(logAndReturn.undefined);
     }
 
-    private onCompileCommandsChanged(path: string, caller: string): void {
-        console.log('onCompileCommandsChanged ', path, caller);
+    private onCompileCommandsChanged(path: string): void {
         this.compileCommandsChanged.fire(path);
     }
 
@@ -1107,7 +1107,7 @@ export class CppProperties {
             }
         }
 
-
+        this.configurationProviderFailedToProvide = false;
         this.updateCompileCommandsFileWatcher();
         if (!this.configurationIncomplete) {
             this.onConfigurationsChanged();
@@ -1119,38 +1119,51 @@ export class CppProperties {
     // Dispose existing and loop through cpp and populate with each file (exists or not) as you go.
     // paths are expected to have variables resolved already
     public updateCompileCommandsFileWatcher(): void {
+        console.log("updateCompileCommandsFileWatcher called");
         // close the existing watcher if it exists
         this.compileCommandsFileWatcher?.close();
         this.compileCommandsFileWatcher = undefined;
 
         // check if the current configuration is using a configuration provider (e.g `CMake Tools`)
         // if so, avoid setting up a `compile_commands.json` file watcher to avoid unnessary parsing
         // by the language server
-        if (this.CurrentConfiguration?.configurationProvider) {
+        if (this.CurrentConfiguration?.configurationProvider && !this.configurationProviderFailedToProvide) {
+            console.log("Skipping compile_commands.json file watcher setup as configuration provider is set");
             return;
         }
 
-        if (this.configurationJson) {
-            const path: string = this.resolvePath(this.CurrentConfiguration?.compileCommands);
-            try {
-                this.compileCommandsFileWatcher = fs.watch(path, () => {
-                    // Wait 1 second after a change to allow time for the write to finish.
+        const path: string = this.resolvePath(this.CurrentConfiguration?.compileCommands);
+        try {
+            this.compileCommandsFileWatcher = fs.watch(path, (eventType: fs.WatchEventType, filename: string | null) => {
+                // Wait 1 second after a change to allow time for the write to finish.
+                clearInterval(this.compileCommandsFileWatcherTimer);
+                this.compileCommandsFileWatcherTimer = setTimeout(() => {
+                    console.log("file watcher triggered for compile_commands.json");
+                    this.onCompileCommandsChanged(path);
                     clearInterval(this.compileCommandsFileWatcherTimer);
-                    this.compileCommandsFileWatcherTimer = setTimeout(() => {
-                        this.onCompileCommandsChanged(path, "file watcher");
-                        clearInterval(this.compileCommandsFileWatcherTimer);
-                        this.compileCommandsFileWatcherTimer = undefined;
-                    }, 1000);
-                })
-            }
-            catch (e: any) {
-                // either file not created or too many watchers
-                // rely on polling until the file is created
-                // then, file watching will be attempted again
-                this.compileCommandsFileWatcher?.close();
-                this.compileCommandsFileWatcher = undefined;
-            }
+                    this.compileCommandsFileWatcherTimer = undefined;
+
+                    // if the file was deleted/renamed, 
+                    // linux based systems lose track of the file (inode deleted)
+                    // we need to close the watcher and wait until file is created again
+                    if (eventType === "rename") {
+                        console.log("compile_commands.json was renamed or deleted, closing watcher");
+                        this.compileCommandsFileWatcher?.close();
+                        this.compileCommandsFileWatcher = undefined;
+                        this.compileCommandsFile = undefined;
+                    }
+                }, 1000);
+            })
+        }
+        catch (e: any) {
+            // either file not created or too many watchers
+            // rely on polling until the file is created
+            // then, file watching will be attempted again
+            console.log("failed to watch compile_commands.json", e);
+            this.compileCommandsFileWatcher?.close();
+            this.compileCommandsFileWatcher = undefined;
         }
+        console.log("file watcher finished");
     }
 
     // onBeforeOpen will be called after c_cpp_properties.json have been created (if it did not exist), but before the document is opened.
@@ -2298,48 +2311,72 @@ export class CppProperties {
         });
     }
 
+
+    /**
+     * if `configurationProvider` is set, we don't watch for changes in the `compileCommands` file.  
+     * calling this function means we need to start checking it.
+     */
+    public configurationProviderFailed(): void {
+        this.configurationProviderFailedToProvide = true;
+    }
+
     /**
      * Manually check for changes in the compileCommands file.  
      * 
      * NOTE: The check is skipped on any of the following terms:
      * - There is an active `compile_commands.json` file watcher
-     * - The `configurationProvider` property is set and the `force` parameter is not set to true
+     * - The `configurationProvider` property is set and `configurationProviderFailed()` was not called
      * - The `compileCommands` property is not set
-     * @param bypassConfigurationProvider bypass the `ConfigurationProvider` is set condition
      */
-    public checkCompileCommands(bypassConfigurationProvider: boolean = false): void {
-        // if the file watcher is active, we don't need to check here for changes
-        if (this.compileCommandsFileWatcher) {
+    public checkCompileCommands(): void {
+        if (this.compileCommandsFileWatcher !== undefined) {
+            console.log("Skipping check for compileCommands file changes, file watcher is active.");
             return;
         }
-        // configuration provider didn't fail to provide a configuration
-        if (this.CurrentConfiguration?.configurationProvider && !bypassConfigurationProvider) {
+        if (this.CurrentConfiguration?.configurationProvider && !this.configurationProviderFailedToProvide) {
+            console.log("Skipping check for compileCommands file changes, configuration provider is set and not forced.");
             return;
         }
-        // Check for changes in case of file watcher failure.
         const compileCommands: string | undefined = this.CurrentConfiguration?.compileCommands;
         if (compileCommands === undefined) {
+            console.log("Skipping check for compileCommands file changes, compileCommands is not set.");
             return;
         }
 
+        console.log("Manually checking for compileCommands file changes.");
         const compileCommandsFile: string | undefined = this.resolvePath(compileCommands);
-        fs.stat(compileCommandsFile, (err, stats) => {
-            if (err) {
-                if (err.code === "ENOENT" && this.compileCommandsFile) {
-                    this.onCompileCommandsChanged(compileCommandsFile, "periodic checker - file deleted");
-                    this.compileCommandsFile = null; // File deleted
-                }
-            } else if (stats.mtime > this.compileCommandsFileWatcherFallbackTime) {
+        try {
+            const stats = fs.statSync(compileCommandsFile);
+            if (this.compileCommandsFile === undefined || stats.mtime > this.compileCommandsFileWatcherFallbackTime) {
                 this.compileCommandsFileWatcherFallbackTime = new Date();
-                this.onCompileCommandsChanged(compileCommandsFile, "periodic checker - file created");
-                this.compileCommandsFile = vscode.Uri.file(compileCommandsFile); // File created.
+                console.log("checkCompileCommands(): compileCommands file changed");
+                this.onCompileCommandsChanged(compileCommandsFile);
+                this.compileCommandsFile = compileCommandsFile; // File created.
             }
-        });
+        }
+        catch (err: any) {
+            if (err.code === "ENOENT" && this.compileCommandsFile) {
+                console.log("checkCompileCommands(): compileCommands file deleted");
+                this.onCompileCommandsChanged(compileCommandsFile);
+                this.compileCommandsFile = undefined; // File deleted
+            }
+        }
+        console.log("checkCompileCommands(): done");
 
-        // if the compileCommands file is set (and not using a configuration provider), try to watch it
-        if (this.compileCommandsFile) {
+        const providerInsufficient: boolean = !this.CurrentConfiguration?.configurationProvider || this.configurationProviderFailedToProvide;
+        if (this.compileCommandsFile !== undefined && providerInsufficient) {
+            console.log("try to watch compileCommands file");
             this.updateCompileCommandsFileWatcher();
         }
+        else {
+            // debug which condition was not met
+            if (this.compileCommandsFile === undefined) {
+                console.log("compileCommandsFile is undefined");
+            }
+            if (this.CurrentConfiguration?.configurationProvider) {
+                console.log("configurationProvider is set");
+            }
+        }
     }
 
     dispose(): void {