Handle multiple compile commands on client side (needs native server side support)

Extension/c_cpp_properties.schema.json

@@ -70,9 +70,22 @@
                         ]
                     },
                     "compileCommands": {
+                        "oneOf": [
+                            {
+                                "type": "string",
+                                "default": ""
+                            },
+                            {
+                                "type": "array",
+                                "items": {
+                                    "type": "string"
+                                },
+                                "uniqueItems": true,
+                                "default": []
+                            }
+                        ],
                         "markdownDescription": "Full path to `compile_commands.json` file for the workspace.",
-                        "descriptionHint": "Markdown text between `` should not be translated or localized (they represent literal text) and the capitalization, spacing, and punctuation (including the ``) should not be altered.",
-                        "type": "string"
+                        "descriptionHint": "Markdown text between `` should not be translated or localized (they represent literal text) and the capitalization, spacing, and punctuation (including the ``) should not be altered."
                     },
                     "includePath": {
                         "markdownDescription": "A list of paths for the IntelliSense engine to use while searching for included headers. Searching on these paths is not recursive. Specify `**` to indicate recursive search. For example, `${workspaceFolder}/**` will search through all subdirectories while `${workspaceFolder}` will not. Usually, this should not include system includes; instead, set `C_Cpp.default.compilerPath`.",

Extension/package.json

@@ -693,7 +693,20 @@
                         "scope": "machine-overridable"
                     },
                     "C_Cpp.default.compileCommands": {
-                        "type": "string",
+                        "oneOf": [
+                            {
+                                "type": "string",
+                                "default": ""
+                            },
+                            {
+                                "type": "array",
+                                "items": {
+                                    "type": "string"
+                                },
+                                "uniqueItems": true,
+                                "default": []
+                            }
+                        ],
                         "markdownDescription": "%c_cpp.configuration.default.compileCommands.markdownDescription%",
                         "scope": "machine-overridable"
                     },

Extension/src/LanguageServer/configurations.ts

@@ -78,8 +78,8 @@
     defines?: string[];
     intelliSenseMode?: string;
     intelliSenseModeIsExplicit?: boolean;
-    compileCommandsInCppPropertiesJson?: string;
-    compileCommands?: string;
+    compileCommandsInCppPropertiesJson?: string[];
+    compileCommands?: string[];
     forcedInclude?: string[];
     configurationProviderInCppPropertiesJson?: string;
     configurationProvider?: string;
@@ -136,7 +136,7 @@
     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 compileCommandsFiles: Set<string> = new Set();
     private compileCommandsFileWatchers: fs.FSWatcher[] = [];
     private compileCommandsFileWatcherFallbackTime: Map<string, Date> = new Map<string, Date>(); // Used when file watching fails.
     private defaultCompilerPath: string | null = null;
@@ -389,7 +389,7 @@
             configuration.windowsSdkVersion = this.defaultWindowsSdkVersion;
         }
         if (isUnset(settings.defaultCompilerPath) && this.defaultCompilerPath &&
-            (isUnset(settings.defaultCompileCommands) || settings.defaultCompileCommands === "") && !configuration.compileCommands) {
+            (isUnset(settings.defaultCompileCommands) || settings.defaultCompileCommands?.length === 0) && !configuration.compileCommands) {
             // compile_commands.json already specifies a compiler. compilerPath overrides the compile_commands.json compiler so
             // don't set a default when compileCommands is in use.
 
@@ -684,7 +684,7 @@
             this.parsePropertiesFile(); // Clear out any modifications we may have made internally.
             const config: Configuration | undefined = this.CurrentConfiguration;
             if (config) {
-                config.compileCommands = path;
+                config.compileCommands = [path];
                 this.writeToJson();
             }
             // Any time parsePropertiesFile is called, configurationJson gets
@@ -938,7 +938,7 @@
             configuration.macFrameworkPath = this.updateConfigurationStringArray(configuration.macFrameworkPath, settings.defaultMacFrameworkPath, env);
             configuration.windowsSdkVersion = this.updateConfigurationString(configuration.windowsSdkVersion, settings.defaultWindowsSdkVersion, env);
             configuration.forcedInclude = this.updateConfigurationPathsArray(configuration.forcedInclude, settings.defaultForcedInclude, env, false);
-            configuration.compileCommands = this.updateConfigurationString(configuration.compileCommands, settings.defaultCompileCommands, env);
+            configuration.compileCommands = this.updateConfigurationStringArray(configuration.compileCommands, settings.defaultCompileCommands, env);
             configuration.compilerArgs = this.updateConfigurationStringArray(configuration.compilerArgs, settings.defaultCompilerArgs, env);
             configuration.cStandard = this.updateConfigurationString(configuration.cStandard, settings.defaultCStandard, env);
             configuration.cppStandard = this.updateConfigurationString(configuration.cppStandard, settings.defaultCppStandard, env);
@@ -1092,11 +1092,13 @@
             }
 
             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());
-                }
+                configuration.compileCommands = configuration.compileCommands?.map((path: string) => this.resolvePath(path));
+                configuration.compileCommands?.forEach((path: string) => {
+                    if (!this.compileCommandsFileWatcherFallbackTime.has(path)) {
+                        // Start tracking the fallback time for a new path.
+                        this.compileCommandsFileWatcherFallbackTime.set(path, new Date());
+                    }
+                });
             }
 
             if (configuration.forcedInclude) {
@@ -1120,10 +1122,12 @@
         // 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);
-            }
+            config.compileCommands?.forEach((path: string) => {
+                const compileCommandsFile = this.resolvePath(path);
+                if (compileCommandsFile.length > 0) {
+                    trackedCompileCommandsPaths.add(compileCommandsFile);
+                }
+            });
         });
 
         for (const path of this.compileCommandsFileWatcherFallbackTime.keys()) {
@@ -1144,12 +1148,12 @@
             this.compileCommandsFileWatchers = []; // reset it
             const filePaths: Set<string> = new Set<string>();
             this.configurationJson.configurations.forEach(c => {
-                if (c.compileCommands) {
-                    const fileSystemCompileCommandsPath: string = this.resolvePath(c.compileCommands);
-                    if (fs.existsSync(fileSystemCompileCommandsPath)) {
-                        filePaths.add(fileSystemCompileCommandsPath);
+                c.compileCommands?.forEach((path: string) => {
+                    const compileCommandsFile: string = this.resolvePath(path);
+                    if (fs.existsSync(compileCommandsFile)) {
+                        filePaths.add(compileCommandsFile);
                     }
-                }
+                })
             });
             try {
                 filePaths.forEach((path: string) => {
@@ -2325,27 +2329,29 @@
 
     public checkCompileCommands(): void {
         // Check for changes in case of file watcher failure.
-        const compileCommands: string | undefined = this.CurrentConfiguration?.compileCommands;
+        const compileCommands: string[] | undefined = this.CurrentConfiguration?.compileCommands;
         if (!compileCommands) {
             return;
         }
-        const compileCommandsFile: string | undefined = this.resolvePath(compileCommands);
-        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 {
-                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.
+        compileCommands.forEach((path: string) => {
+            const compileCommandsFile: string | undefined = this.resolvePath(path);
+            fs.stat(compileCommandsFile, (err, stats) => {
+                if (err) {
+                    if (err.code === "ENOENT" && this.compileCommandsFiles.has(compileCommandsFile)) {
+                        this.compileCommandsFileWatchers.forEach((watcher: fs.FSWatcher) => watcher.close());
+                        this.compileCommandsFileWatchers = []; // reset file watchers
+                        this.onCompileCommandsChanged(compileCommandsFile);
+                        this.compileCommandsFiles.delete(compileCommandsFile); // File deleted
+                    }
+                } 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.compileCommandsFiles.add(compileCommandsFile); // File created.
+                    }
                 }
-            }
+            });
         });
     }
 

Extension/src/LanguageServer/settings.ts

@@ -399,12 +399,30 @@
     public get defaultDotconfig(): string | undefined { return changeBlankStringToUndefined(this.getAsStringOrUndefined("default.dotConfig")); }
     public get defaultMacFrameworkPath(): string[] | undefined { return this.getArrayOfStringsWithUndefinedDefault("default.macFrameworkPath"); }
     public get defaultWindowsSdkVersion(): string | undefined { return changeBlankStringToUndefined(this.getAsStringOrUndefined("default.windowsSdkVersion")); }
-    public get defaultCompileCommands(): string | undefined { return changeBlankStringToUndefined(this.getAsStringOrUndefined("default.compileCommands")); }
     public get defaultForcedInclude(): string[] | undefined { return this.getArrayOfStringsWithUndefinedDefault("default.forcedInclude"); }
     public get defaultIntelliSenseMode(): string | undefined { return this.getAsStringOrUndefined("default.intelliSenseMode"); }
     public get defaultCompilerPath(): string | null { return this.getAsString("default.compilerPath", true); }
+    public get defaultCompileCommands(): string[] | undefined {
+        // Try to get the value as a string.
+        const value: string | undefined = this.getAsStringOrUndefined("default.compileCommands");
+        if (value !== undefined) {
+            if (changeBlankStringToUndefined(value) === undefined) {
+                return undefined;
+            }
+            return [value];
+        }
+
+        // value is not a string, try to get it as an array of strings instead.
+        var valueArray: string[] | undefined = this.getAsArrayOfStringsOrUndefined("default.compileCommands");
+        valueArray = valueArray?.filter((value) => value !== "");
+        if (valueArray?.length === 0) {
+            return undefined;
+        }
+        return valueArray;
+    }
+
 
     public set defaultCompilerPath(value: string) {
         const defaultCompilerPathStr: string = "default.compilerPath";
         const compilerPathInfo: any = this.Section.inspect(defaultCompilerPathStr);
         let target: vscode.ConfigurationTarget = vscode.ConfigurationTarget.Global;
@@ -638,7 +656,7 @@
         }
 
         if (isArrayOfString(value)) {
-            if (setting.items.enum && !allowUndefinedEnums) {
+            if (setting.items?.enum !== undefined && !allowUndefinedEnums) {
                 if (!value.every(x => this.isValidEnum(setting.items.enum, x))) {
                     return setting.default;
                 }