Don't show the 'select a compiler' code action if the default compiler is already set (and other quick fixes) (#10670)

* Stop showing the code action if the default compiler is already set.
* Multiple other fixes.
* Fix clang-tidy 'clang-analyzer-' documentation links not working.

Author: sean-mcmanus

Extension/CHANGELOG.md

@@ -1,10 +1,12 @@
 # C/C++ for Visual Studio Code Changelog
 
-## Version 1.15.0: March 14, 2023
+## Version 1.15.0: March 15, 2023
 ### Enhancements
 * Support multiple natvis files in `visualizerFile`. [#925](https://github.com/microsoft/vscode-cpptools/issues/925)
 * Enable error squiggles for single file mode if includes resolve. [#10062](https://github.com/microsoft/vscode-cpptools/issues/10062)
+* Improve the description of the `C_Cpp.codeAnalysis.clangTidy.enabled` setting. [#10454](https://github.com/microsoft/vscode-cpptools/issues/10454)
 * Add a 'Select Default Compiler' code action and error message for standard headers which can't be found. [#10531](https://github.com/microsoft/vscode-cpptools/issues/10531)
+* Change the 'Edit "includePath" setting' code action to reference "compilerPath" for missing system includes. [#10675](https://github.com/microsoft/vscode-cpptools/issues/10675)
 
 ### Bug Fixes
 * Enable `-fms-extensions` by default for Cygwin and MinGW. [#8353](https://github.com/microsoft/vscode-cpptools/issues/8353)
@@ -20,9 +22,11 @@
 * Fix 'Reset IntelliSense Database' being delayed until parsing is finished. [#10616](https://github.com/microsoft/vscode-cpptools/issues/10616)
 * Fix uncaught exception with some configuration providers. [PR #10629](https://github.com/microsoft/vscode-cpptools/pull/10629)
 * Fix bugs with the "You do not have IntelliSense configured" prompt. [#10658](https://github.com/microsoft/vscode-cpptools/issues/10658), [#10659](https://github.com/microsoft/vscode-cpptools/issues/10659)
+* Fix random failures when adding or removing workspace folders. [PR #10665](https://github.com/microsoft/vscode-cpptools/pull/10665)
 * Fix missing clang-tidy checks setting values. [#10667](https://github.com/microsoft/vscode-cpptools/issues/10667)
+* Fix 'Select Default Compiler' so that it works if it's already set in the workspace or workspace folder settings. [#10674](https://github.com/microsoft/vscode-cpptools/issues/10674)
+* Fix clang-tidy 'clang-analyzer-' documentation links not working. [#10678](https://github.com/microsoft/vscode-cpptools/issues/10678)
 * Fix `__GXX_RTTI` incorrectly being defined by IntelliSense with clang and `-fms-compatibility`.
-* Fix random failures when adding or removing workspace folders.
 * Reduce the likelihood of an `onWillSaveWaitUntil` timeout.
 * Fix an IntelliSense crash with C++20 concepts.
 * Stop querying clang-cl.exe as C.

Extension/src/LanguageServer/Providers/codeActionProvider.ts

@@ -67,9 +67,12 @@ export class CodeActionProvider implements vscode.CodeActionProvider {
             throw new vscode.CancellationError();
         }
 
+        let hasSelectDefaultCompiler: boolean = false;
+        let hasConfigurationCompilerPath: boolean = false;
+
         // Convert to vscode.CodeAction array
         response.commands.forEach((command) => {
-            const title: string = getLocalizedString(command.localizeStringParams);
+            let title: string = getLocalizedString(command.localizeStringParams);
             let wsEdit: vscode.WorkspaceEdit | undefined;
             let codeActionKind: vscode.CodeActionKind = vscode.CodeActionKind.QuickFix;
             if (command.edit) {
@@ -168,9 +171,20 @@ export class CodeActionProvider implements vscode.CodeActionProvider {
                 resultCodeActions.push(...disableCodeActions);
                 resultCodeActions.push(...docCodeActions);
                 return;
-            }
-            if (command.command === 'C_Cpp.CreateDeclarationOrDefinition' && (command.arguments ?? []).length === 0) {
+            } else if (command.command === 'C_Cpp.CreateDeclarationOrDefinition' && (command.arguments ?? []).length === 0) {
                 command.arguments = ['codeAction']; // We report the sender of the command
+            } else if (command.command === "C_Cpp.SelectDefaultCompiler") {
+                hasSelectDefaultCompiler = true;
+                if (this.client.configuration.CurrentConfiguration?.rawCompilerPath !== undefined) {
+                    hasConfigurationCompilerPath = true;
+                    return;
+                }
+            } else if (command.command === "C_Cpp.ConfigurationEdit" && hasSelectDefaultCompiler) {
+                if (hasConfigurationCompilerPath) {
+                    title = title.replace("includePath", "compilerPath");
+                } else {
+                    return;
+                }
             }
             const vscodeCodeAction: vscode.CodeAction = {
                 title: title,

Extension/src/LanguageServer/client.ts

@@ -953,7 +953,7 @@ export class DefaultClient implements Client {
     }
 
     public async handleCompilerQuickPick(showSecondPrompt: boolean): Promise<void> {
-        const settings: OtherSettings = new OtherSettings();
+        const settings: CppSettings = new CppSettings();
         const selectCompiler: string = localize("selectCompiler.string", "Select Compiler");
         const paths: string[] = [];
         if (compilerDefaults.knownCompilers !== undefined) {
@@ -988,7 +988,7 @@ export class DefaultClient implements Client {
             }
             if (index === paths.length - 1) {
                 action = "disable";
-                settings.defaultCompiler = "";
+                settings.defaultCompilerPath = "";
                 if (showSecondPrompt) {
                     this.showPrompt(selectCompiler, true);
                 }
@@ -1018,13 +1018,13 @@ export class DefaultClient implements Client {
                     return;
                 }
                 action = "compiler browsed";
-                settings.defaultCompiler = result[0].fsPath;
+                settings.defaultCompilerPath = result[0].fsPath;
             } else {
                 action = "select compiler";
-                settings.defaultCompiler = util.isCl(paths[index]) ? "cl.exe" : paths[index];
+                settings.defaultCompilerPath = util.isCl(paths[index]) ? "cl.exe" : paths[index];
             }
 
-            util.addTrustedCompiler(compilerPaths, settings.defaultCompiler);
+            util.addTrustedCompiler(compilerPaths, settings.defaultCompilerPath);
             compilerDefaults = await this.requestCompiler(compilerPaths);
             DefaultClient.updateClientConfigurations();
         } finally {
@@ -1040,13 +1040,13 @@ export class DefaultClient implements Client {
         const selectCompiler: string = localize("selectCompiler.string", "Select Compiler");
         const confirmCompiler: string = localize("confirmCompiler.string", "Yes");
         let action: string;
-        const settings: OtherSettings = new OtherSettings();
+        const settings: CppSettings = new CppSettings();
         if (isCommand || compilerDefaults.compilerPath !== "") {
             if (!isCommand && (compilerDefaults.compilerPath !== undefined)) {
                 const value: string | undefined = await vscode.window.showInformationMessage(localize("selectCompiler.message", "The compiler {0} was found. Do you want to configure IntelliSense with this compiler?", compilerDefaults.compilerPath), confirmCompiler, selectCompiler);
                 if (value === confirmCompiler) {
                     compilerPaths = await util.addTrustedCompiler(compilerPaths, compilerDefaults.compilerPath);
-                    settings.defaultCompiler = compilerDefaults.compilerPath;
+                    settings.defaultCompilerPath = compilerDefaults.compilerPath;
                     compilerDefaults = await this.requestCompiler(compilerPaths);
                     DefaultClient.updateClientConfigurations();
                     action = "confirm compiler";

Extension/src/LanguageServer/codeAnalysis.ts

@@ -349,7 +349,9 @@ export function publishCodeAnalysisDiagnostics(params: PublishCodeAnalysisDiagno
                 if (primaryCode === "clang-tidy-nolint") {
                     docPage = "index.html#suppressing-undesired-diagnostics";
                 } else {
-                    const dashIndex: number = primaryCode.indexOf("-");
+                    const clangAnalyzerString: string = "clang-analyzer";
+                    const clangAnalyzerIndex: number = primaryCode.indexOf(clangAnalyzerString);
+                    const dashIndex: number = clangAnalyzerIndex === 0 ? clangAnalyzerString.length : primaryCode.indexOf("-");
                     const checksGroup: string = dashIndex > 0 ? `/${primaryCode.substring(0, dashIndex)}` : "";
                     const checksPage: string = dashIndex > 0 ? primaryCode.substring(dashIndex + 1) : primaryCode;
                     docPage = `checks${checksGroup}/${checksPage}.html`;

Extension/src/LanguageServer/configurations.ts

@@ -58,6 +58,7 @@ export interface ConfigurationJson {
 
 export interface Configuration {
     name: string;
+    rawCompilerPath?: string;
     compilerPath?: string;
     compilerPathIsExplicit?: boolean;
     compilerArgs?: string[];
@@ -837,6 +838,7 @@ export class CppProperties {
         const env: Environment = this.ExtendedEnvironment;
         for (let i: number = 0; i < this.configurationJson.configurations.length; i++) {
             const configuration: Configuration = this.configurationJson.configurations[i];
+            configuration.rawCompilerPath = configuration.compilerPath;
 
             configuration.includePath = this.updateConfigurationPathsArray(configuration.includePath, settings.defaultIncludePath, env);
             // in case includePath is reset below

Extension/src/LanguageServer/settings.ts

@@ -379,6 +379,14 @@ export class CppSettings extends Settings {
     public get defaultForcedInclude(): string[] | undefined { return super.getWithUndefinedDefault<string[]>("default.forcedInclude"); }
     public get defaultIntelliSenseMode(): string | undefined { return super.Section.get<string>("default.intelliSenseMode"); }
     public get defaultCompilerPath(): string | undefined { return super.Section.get<string | null>("default.compilerPath") ?? undefined; }
+    public set defaultCompilerPath(value: string | undefined) {
+        const defaultCompilerPathStr: string = "default.compilerPath";
+        const compilerPathInfo: any = this.Section.inspect(defaultCompilerPathStr);
+        this.Section.update(defaultCompilerPathStr, value,
+            compilerPathInfo.workspaceFolderValue !== undefined ? vscode.ConfigurationTarget.WorkspaceFolder :
+                (compilerPathInfo.workspaceValue !== undefined ? vscode.ConfigurationTarget.Workspace :
+                    vscode.ConfigurationTarget.Global));
+    }
     public get defaultCompilerArgs(): string[] | undefined { return super.getWithUndefinedDefault<string[]>("default.compilerArgs"); }
     public get defaultCStandard(): string | undefined { return super.Section.get<string>("default.cStandard"); }
     public get defaultCppStandard(): string | undefined { return super.Section.get<string>("default.cppStandard"); }
@@ -964,9 +972,6 @@ export class OtherSettings {
     public set filesAssociations(value: any) {
         vscode.workspace.getConfiguration("files").update("associations", value, vscode.ConfigurationTarget.Workspace);
     }
-    public set defaultCompiler(value: string) {
-        vscode.workspace.getConfiguration("C_Cpp.default").update("compilerPath", value, vscode.ConfigurationTarget.Global);
-    }
     public get filesExclude(): vscode.WorkspaceConfiguration | undefined { return vscode.workspace.getConfiguration("files", this.resource).get("exclude"); }
     public get filesAutoSaveAfterDelay(): boolean { return vscode.workspace.getConfiguration("files").get("autoSave") === "afterDelay"; }
     public get editorInlayHintsEnabled(): boolean { return vscode.workspace.getConfiguration("editor.inlayHints").get<string>("enabled") !== "off"; }