Add "Configure Intellisense" Status Bar Item

Extension/src/LanguageServer/Providers/codeActionProvider.ts

@@ -174,6 +174,7 @@ export class CodeActionProvider implements vscode.CodeActionProvider {
  } 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") {
+ command.arguments = ['codeAction'];
  hasSelectDefaultCompiler = true;
  if (this.client.configuration.CurrentConfiguration?.rawCompilerPath !== undefined) {
  hasConfigurationCompilerPath = true;

Extension/src/LanguageServer/client.ts

@@ -760,7 +760,7 @@ export interface Client {
  selectionChanged(selection: Range): void;
  resetDatabase(): void;
  deactivate(): void;
- promptSelectCompiler(command: boolean): Promise<void>;
+ promptSelectCompiler(command: boolean, sender?: any): Promise<void>;
  pauseParsing(): void;
  resumeParsing(): void;
  PauseCodeAnalysis(): void;
@@ -942,17 +942,17 @@ export class DefaultClient implements Client {
  return (selection) ? selection.index : -1;
  }
 
- public async showPrompt(buttonMessage: string, showSecondPrompt: boolean): Promise<void> {
+ public async showPrompt(buttonMessage: string, showSecondPrompt: boolean, sender?: any): Promise<void> {
  if (secondPromptCounter < 1) {
  const value: string | undefined = await vscode.window.showInformationMessage(localize("setCompiler.message", "You do not have IntelliSense configured. Unless you set your own configurations, IntelliSense may not be functional."), buttonMessage);
  secondPromptCounter++;
  if (value === buttonMessage) {
- this.handleCompilerQuickPick(showSecondPrompt);
+ this.handleCompilerQuickPick(showSecondPrompt, sender);
  }
  }
  }
 
- public async handleCompilerQuickPick(showSecondPrompt: boolean): Promise<void> {
+ public async handleCompilerQuickPick(showSecondPrompt: boolean, sender?: any): Promise<void> {
  const settings: CppSettings = new CppSettings();
  const selectCompiler: string = localize("selectCompiler.string", "Select Compiler");
  const paths: string[] = [];
@@ -982,16 +982,17 @@ export class DefaultClient implements Client {
  if (index === -1) {
  action = "escaped";
  if (showSecondPrompt && !compilerDefaults.trustedCompilerFound) {
- this.showPrompt(selectCompiler, true);
+ this.showPrompt(selectCompiler, true, sender);
  }
  return;
  }
  if (index === paths.length - 1) {
  action = "disable";
  settings.defaultCompilerPath = "";
  if (showSecondPrompt) {
- this.showPrompt(selectCompiler, true);
+ this.showPrompt(selectCompiler, true, sender);
  }
+ ui.showCompilerStatusIcon(false);
  return;
  }
  if (index === paths.length - 2) {
@@ -1012,27 +1013,29 @@ export class DefaultClient implements Client {
  const result: vscode.Uri[] | undefined = await vscode.window.showOpenDialog();
  if (result === undefined || result.length === 0) {
  if (showSecondPrompt && !compilerDefaults.trustedCompilerFound) {
- this.showPrompt(selectCompiler, true);
+ this.showPrompt(selectCompiler, true, sender);
  }
  action = "browse dismissed";
  return;
  }
  action = "compiler browsed";
  settings.defaultCompilerPath = result[0].fsPath;
+ ui.showCompilerStatusIcon(false);
  } else {
  action = "select compiler";
  settings.defaultCompilerPath = util.isCl(paths[index]) ? "cl.exe" : paths[index];
+ ui.showCompilerStatusIcon(false);
  }
 
  util.addTrustedCompiler(compilerPaths, settings.defaultCompilerPath);
  compilerDefaults = await this.requestCompiler(compilerPaths);
  DefaultClient.updateClientConfigurations();
  } finally {
- telemetry.logLanguageServerEvent('compilerSelection', { action }, { compilerCount: paths.length });
+ telemetry.logLanguageServerEvent('compilerSelection', { action, sender: util.getSenderType(sender)}, { compilerCount: paths.length });
  }
  }
 
- async promptSelectCompiler(isCommand: boolean): Promise<void> {
+ async promptSelectCompiler(isCommand: boolean, sender?: any): Promise<void> {
  secondPromptCounter = 0;
  if (compilerDefaults === undefined) {
  return;
@@ -1049,19 +1052,20 @@ export class DefaultClient implements Client {
  settings.defaultCompilerPath = compilerDefaults.compilerPath;
  compilerDefaults = await this.requestCompiler(compilerPaths);
  DefaultClient.updateClientConfigurations();
+ ui.showCompilerStatusIcon(false);
  action = "confirm compiler";
  } else if (value === selectCompiler) {
- this.handleCompilerQuickPick(true);
+ this.handleCompilerQuickPick(true, sender);
  action = "show quickpick";
  } else {
- this.showPrompt(selectCompiler, true);
+ this.showPrompt(selectCompiler, true, sender);
  action = "dismissed";
  }
  telemetry.logLanguageServerEvent('compilerNotification', { action });
  } else if (!isCommand && (compilerDefaults.compilerPath === undefined)) {
- this.showPrompt(selectCompiler, false);
+ this.showPrompt(selectCompiler, false, sender);
  } else {
- this.handleCompilerQuickPick(isCommand);
+ this.handleCompilerQuickPick(isCommand, sender);
  }
  }
  }
@@ -1186,8 +1190,9 @@ export class DefaultClient implements Client {
  compilerDefaults = await this.requestCompiler(compilerPaths);
  DefaultClient.updateClientConfigurations();
  if (!compilerDefaults.trustedCompilerFound && !displayedSelectCompiler && (compilerPaths.length !== 1 || compilerPaths[0] !== "")) {
+ await ui.showCompilerStatusIcon(true);
  // if there is no compilerPath in c_cpp_properties.json, prompt user to configure a compiler
- this.promptSelectCompiler(false);
+ this.promptSelectCompiler(false, 'initialization');
  displayedSelectCompiler = true;
  }
  }
@@ -3522,7 +3527,7 @@ class NullClient implements Client {
  activate(): void { }
  selectionChanged(selection: Range): void { }
  resetDatabase(): void { }
- promptSelectCompiler(command: boolean): Promise<void> { return Promise.resolve(); }
+ promptSelectCompiler(command: boolean, sender?: any): Promise<void> { return Promise.resolve(); }
  deactivate(): void { }
  pauseParsing(): void { }
  resumeParsing(): void { }

Extension/src/LanguageServer/extension.ts

@@ -434,20 +434,11 @@ function logForUIExperiment(command: string, sender?: any): void {
  const properties: {[key: string]: string} = {
  newUI: ui.isNewUI.toString(),
  uiOverride: (settings.experimentalFeatures ?? false).toString(),
- sender: getSenderType(sender)
+ sender: util.getSenderType(sender)
  };
  telemetry.logLanguageServerEvent(`experiment${command}`, properties);
 }
 
-function getSenderType(sender?: any): string {
- if (util.isString(sender)) {
- return sender;
- } else if (util.isUri(sender)) {
- return 'contextMenu';
- }
- return 'commandPalette';
-}
-
 function onDisabledCommand(): void {
  const message: string = localize(
  {
@@ -541,8 +532,8 @@ function onResetDatabase(): void {
  clients.ActiveClient.resetDatabase();
 }
 
-function selectDefaultCompiler(): void {
- clients.ActiveClient.promptSelectCompiler(true);
+function selectDefaultCompiler(sender?: any): void {
+ clients.ActiveClient.promptSelectCompiler(true, sender);
 }
 
 function onSelectConfiguration(sender?: any): void {
@@ -690,7 +681,7 @@ async function onDisableAllTypeCodeAnalysisProblems(code: string, identifiersAnd
 
 async function onCreateDeclarationOrDefinition(sender?: any): Promise<void> {
  const properties: { [key: string]: string } = {
- sender: getSenderType(sender)
+ sender: util.getSenderType(sender)
  };
  telemetry.logLanguageServerEvent('CreateDeclDefn', properties);
  getActiveClient().handleCreateDeclarationOrDefinition();

Extension/src/LanguageServer/ui.ts

@@ -23,6 +23,7 @@ export interface UI {
  activeDocumentChanged(): void;
  bind(client: Client): void;
  showConfigurations(configurationNames: string[]): Promise<number>;
+ showCompilerStatusIcon(show: boolean): Promise<void>;
  showConfigurationProviders(currentProvider?: string): Promise<string | undefined>;
  showCompileCommands(paths: string[]): Promise<number>;
  showWorkspaces(workspaceNames: { name: string; key: string }[]): Promise<string>;
@@ -60,6 +61,7 @@ export class OldUI implements UI {
  private configStatusBarItem: vscode.StatusBarItem;
  private browseEngineStatusBarItem: vscode.StatusBarItem;
  private intelliSenseStatusBarItem: vscode.StatusBarItem;
+ private compilerStatusItem: vscode.StatusBarItem;
  private referencesStatusBarItem: vscode.StatusBarItem;
  private curConfigurationStatus?: Promise<ConfigurationStatus>;
  private isParsingWorkspace: boolean = false;
@@ -102,6 +104,17 @@ export class OldUI implements UI {
  };
  this.ShowReferencesIcon = false;
 
+ this.compilerStatusItem = vscode.window.createStatusBarItem(`c.cpp.compilerStatus.statusbar`, vscode.StatusBarAlignment.Right, 901);
+ this.compilerStatusItem.name = localize("c.cpp.compilerStatus.statusbar", "Configure IntelliSense");
+ this.compilerStatusItem.text = `$(warning) ${this.compilerStatusItem.name}`;
+ this.compilerStatusItem.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+ this.compilerStatusItem.command = {
+ command: "C_Cpp.SelectDefaultCompiler",
+ title: this.compilerStatusItem.name,
+ arguments: ['statusBar']
+ };
+ this.showCompilerStatusIcon(false);
+
  this.intelliSenseStatusBarItem = vscode.window.createStatusBarItem("c.cpp.intellisense.statusbar", vscode.StatusBarAlignment.Right, 903);
  this.intelliSenseStatusBarItem.name = localize("c.cpp.intellisense.statusbar", "C/C++ IntelliSense Status");
  this.intelliSenseStatusBarItem.tooltip = this.updatingIntelliSenseTooltip;
@@ -294,6 +307,24 @@ export class OldUI implements UI {
  }
  }
 
+ private compilerTimout?: NodeJS.Timeout;
+ public async showCompilerStatusIcon(show: boolean): Promise<void> {
+ if (!telemetry.showStatusBarIntellisenseIndicator()) {
+ return;
+ }
+ if (this.compilerTimout) {
+ clearTimeout(this.compilerTimout);
+ }
+ if (show) {
+ this.compilerTimout = setTimeout(() => {
+ this.compilerStatusItem.show();
+ telemetry.logLanguageServerEvent('compilerStatusBar');
+ }, 15000);
+ } else {
+ this.compilerStatusItem.hide();
+ }
+ }
+
  public activeDocumentChanged(): void {
  const activeEditor: vscode.TextEditor | undefined = vscode.window.activeTextEditor;
  if (!activeEditor) {

Extension/src/LanguageServer/ui_new.ts

@@ -13,6 +13,7 @@ import * as nls from 'vscode-nls';
 import { setTimeout } from 'timers';
 import { CppSettings } from './settings';
 import { UI } from './ui';
+import * as telemetry from '../telemetry';
 
 nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
 const localize: nls.LocalizeFunc = nls.loadMessageBundle();
@@ -49,6 +50,7 @@ export class NewUI implements UI {
  private configStatusItem: vscode.LanguageStatusItem;
  private browseEngineStatusItem: vscode.LanguageStatusItem;
  private intelliSenseStatusItem: vscode.LanguageStatusItem;
+ private compilerStatusItem: vscode.StatusBarItem;
  private referencesStatusBarItem: vscode.StatusBarItem;
  private codeAnalysisStatusItem: vscode.LanguageStatusItem;
  private configDocumentSelector: vscode.DocumentFilter[] = [
@@ -112,6 +114,17 @@ export class NewUI implements UI {
  };
  this.ShowReferencesIcon = false;
 
+ this.compilerStatusItem = vscode.window.createStatusBarItem(`c.cpp.compilerStatus.statusbar`, vscode.StatusBarAlignment.Right, 901);
+ this.compilerStatusItem.name = localize("c.cpp.compilerStatus.statusbar", "Configure IntelliSense");
+ this.compilerStatusItem.text = `$(warning) ${this.compilerStatusItem.name}`;
+ this.compilerStatusItem.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+ this.compilerStatusItem.command = {
+ command: "C_Cpp.SelectDefaultCompiler",
+ title: this.compilerStatusItem.name,
+ arguments: ['statusBar']
+ };
+ this.showCompilerStatusIcon(false);
+
  this.intelliSenseStatusItem = vscode.languages.createLanguageStatusItem(`cpptools.status.${LanguageStatusPriority.Mid}.intellisense`, documentSelector);
  this.intelliSenseStatusItem.name = localize("cpptools.status.intellisense", "C/C++ IntelliSense Status");
  this.intelliSenseStatusItem.text = this.idleIntelliSenseText;
@@ -403,6 +416,24 @@ export class NewUI implements UI {
  }
  }
 
+ private compilerTimout?: NodeJS.Timeout;
+ public async showCompilerStatusIcon(show: boolean): Promise<void> {
+ if (!telemetry.showStatusBarIntellisenseIndicator()) {
+ return;
+ }
+ if (this.compilerTimout) {
+ clearTimeout(this.compilerTimout);
+ }
+ if (show) {
+ this.compilerTimout = setTimeout(() => {
+ this.compilerStatusItem.show();
+ telemetry.logLanguageServerEvent('compilerStatusBar');
+ }, 15000);
+ } else {
+ this.compilerStatusItem.hide();
+ }
+ }
+
  public activeDocumentChanged(): void {
  const activeEditor: vscode.TextEditor | undefined = vscode.window.activeTextEditor;
  if (activeEditor) {

Extension/src/common.ts

@@ -1188,6 +1188,15 @@ export class BlockingTask<T> {
  }
 }
 
+export function getSenderType(sender?: any): string {
+ if (isString(sender)) {
+ return sender;
+ } else if (isUri(sender)) {
+ return 'contextMenu';
+ }
+ return 'commandPalette';
+}
+
 function decodeUCS16(input: string): number[] {
  const output: number[] = [];
  let counter: number = 0;

Extension/src/telemetry.ts

@@ -139,6 +139,15 @@ export function logLanguageServerEvent(eventName: string, properties?: { [key: s
  sendTelemetry();
 }
 
+export async function showStatusBarIntellisenseIndicator(): Promise<boolean> {
+ if (new CppSettings().experimentalFeatures) {
+ return true;
+ }
+ const experimentationService: IExperimentationService | undefined = await getExperimentationService();
+ const useNewUI: boolean | undefined = experimentationService?.getTreatmentVariable<boolean>("vscode", "showStatusBarIntellisenseIndicator");
+ return useNewUI ?? false;
+}
+
 function getPackageInfo(): IPackageInfo {
  return {
  name: util.packageJson.publisher + "." + util.packageJson.name,