Support for copilot-generated summaries in quick info. (On-the-fly docs)

Extension/package.json

@@ -3286,6 +3286,17 @@
                         "default": false,
                         "markdownDescription": "%c_cpp.configuration.addNodeAddonIncludePaths.markdownDescription%",
                         "scope": "application"
+                    },
+                    "C_Cpp.copilotHover": {
+                        "type": "string",
+                        "enum": [
+                            "default",
+                            "enabled",
+                            "disabled"
+                        ],
+                        "default": "default",
+                        "markdownDescription": "%c_cpp.configuration.copilotHover.markdownDescription%",
+                        "scope": "window"
                     }
                 }
             }

Extension/package.nls.json

@@ -775,6 +775,12 @@
             "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."
         ]
     },
+    "c_cpp.configuration.copilotHover.markdownDescription": {
+        "message": "If `enabled`, the hover tooltip will display an option to generate a summary of the symbol with Copilot. If `disabled`, the option will not be displayed.",
+        "comment": [
+            "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."
+        ]
+    },
     "c_cpp.configuration.renameRequiresIdentifier.markdownDescription": {
         "message": "If `true`, 'Rename Symbol' will require a valid C/C++ identifier.",
         "comment": [

Extension/src/LanguageServer/client.ts

@@ -541,6 +541,21 @@ interface GetIncludesResult {
     includedFiles: string[];
 }
 
+interface ShowCopilotHoverParams
+{
+    content: string;
+}
+
+interface ShowCopilotHoverResult
+{
+    hoverPos: Position;
+}
+
+interface GetCopilotHoverInfoResult
+{
+    content: string;
+}
+
 // Requests
 const PreInitializationRequest: RequestType<void, string, void> = new RequestType<void, string, void>('cpptools/preinitialize');
 const InitializationRequest: RequestType<CppInitializationParams, void, void> = new RequestType<CppInitializationParams, void, void>('cpptools/initialize');
@@ -560,6 +575,8 @@ const GoToDirectiveInGroupRequest: RequestType<GoToDirectiveInGroupParams, Posit
 const GenerateDoxygenCommentRequest: RequestType<GenerateDoxygenCommentParams, GenerateDoxygenCommentResult | undefined, void> = new RequestType<GenerateDoxygenCommentParams, GenerateDoxygenCommentResult, void>('cpptools/generateDoxygenComment');
 const ChangeCppPropertiesRequest: RequestType<CppPropertiesParams, void, void> = new RequestType<CppPropertiesParams, void, void>('cpptools/didChangeCppProperties');
 const IncludesRequest: RequestType<GetIncludesParams, GetIncludesResult, void> = new RequestType<GetIncludesParams, GetIncludesResult, void>('cpptools/getIncludes');
+const GetCopilotHoverInfoRequest: RequestType<void, GetCopilotHoverInfoResult, void> = new RequestType<void, GetCopilotHoverInfoResult, void>('cpptools/getCopilotHoverInfo');
+const ShowCopilotHoverRequest: RequestType<ShowCopilotHoverParams, ShowCopilotHoverResult, void> = new RequestType<ShowCopilotHoverParams, ShowCopilotHoverResult, void>('cpptools/showCopilotHover');
 
 // Notifications to the server
 const DidOpenNotification: NotificationType<DidOpenTextDocumentParams> = new NotificationType<DidOpenTextDocumentParams>('textDocument/didOpen');
@@ -790,6 +807,8 @@ export interface Client {
     setShowConfigureIntelliSenseButton(show: boolean): void;
     addTrustedCompiler(path: string): Promise<void>;
     getIncludes(maxDepth: number): Promise<GetIncludesResult>;
+    showCopilotHover(content: string): Promise<ShowCopilotHoverResult>;
+    getCopilotHoverInfo(): Promise<GetCopilotHoverInfoResult>;
 }
 
 export function createClient(workspaceFolder?: vscode.WorkspaceFolder): Client {
@@ -1441,7 +1460,7 @@ export class DefaultClient implements Client {
         return workspaceFolderSettingsParams;
     }
 
-    private getAllSettings(): SettingsParams {
+    private async getAllSettings(): Promise<SettingsParams> {
         const workspaceSettings: CppSettings = new CppSettings();
         const workspaceOtherSettings: OtherSettings = new OtherSettings();
         const workspaceFolderSettingsParams: WorkspaceFolderSettingsParams[] = this.getAllWorkspaceFolderSettings();
@@ -1467,6 +1486,7 @@ export class DefaultClient implements Client {
             codeAnalysisMaxConcurrentThreads: workspaceSettings.codeAnalysisMaxConcurrentThreads,
             codeAnalysisMaxMemory: workspaceSettings.codeAnalysisMaxMemory,
             codeAnalysisUpdateDelay: workspaceSettings.codeAnalysisUpdateDelay,
+            copilotHover: await workspaceSettings.copilotHover,
             workspaceFolderSettings: workspaceFolderSettingsParams
         };
     }
@@ -1536,7 +1556,7 @@ export class DefaultClient implements Client {
             resetDatabase: resetDatabase,
             edgeMessagesDirectory: path.join(util.getExtensionFilePath("bin"), "messages", getLocaleId()),
             localizedStrings: localizedStrings,
-            settings: this.getAllSettings()
+            settings: await this.getAllSettings()
         };
 
         this.loggingLevel = util.getNumericLoggingLevel(cppInitializationParams.settings.loggingLevel);
@@ -1577,6 +1597,12 @@ export class DefaultClient implements Client {
                     // We manually restart the language server so tell the LanguageClient not to do it automatically for us.
                     return { action: CloseAction.DoNotRestart, message };
                 }
+            },
+            markdown: {
+                isTrusted: true
+                // TODO: support for icons in markdown is not yet in the released version of vscode-languageclient.
+                // Based on PR (https://github.com/microsoft/vscode-languageserver-node/pull/1504)
+                //supportThemeIcons: true
             }
 
             // TODO: should I set the output channel? Does this sort output between servers?
@@ -1602,7 +1628,7 @@ export class DefaultClient implements Client {
     public async sendDidChangeSettings(): Promise<void> {
         // Send settings json to native side
         await this.ready;
-        await this.languageClient.sendNotification(DidChangeSettingsNotification, this.getAllSettings());
+        await this.languageClient.sendNotification(DidChangeSettingsNotification, await this.getAllSettings());
     }
 
     public async onDidChangeSettings(_event: vscode.ConfigurationChangeEvent): Promise<Record<string, string>> {
@@ -3972,6 +3998,17 @@ export class DefaultClient implements Client {
         compilerDefaults = await this.requestCompiler(path);
         DebugConfigurationProvider.ClearDetectedBuildTasks();
     }
+
+    public async showCopilotHover(content: string): Promise<ShowCopilotHoverResult> {
+        const params: ShowCopilotHoverParams = {content: content};
+        await this.ready;
+        return this.languageClient.sendRequest(ShowCopilotHoverRequest, params);
+    }
+
+    public async getCopilotHoverInfo(): Promise<GetCopilotHoverInfoResult> {
+        await this.ready;
+        return this.languageClient.sendRequest(GetCopilotHoverInfoRequest, null);
+    }
 }
 
 function getLanguageServerFileName(): string {
@@ -4084,4 +4121,6 @@ class NullClient implements Client {
     setShowConfigureIntelliSenseButton(show: boolean): void { }
     addTrustedCompiler(path: string): Promise<void> { return Promise.resolve(); }
     getIncludes(): Promise<GetIncludesResult> { return Promise.resolve({} as GetIncludesResult); }
+    showCopilotHover(content: string): Promise<ShowCopilotHoverResult> { return Promise.resolve({} as ShowCopilotHoverResult); }
+    getCopilotHoverInfo(): Promise<GetCopilotHoverInfoResult> { return Promise.resolve({} as GetCopilotHoverInfoResult); }
 }

Extension/src/LanguageServer/extension.ts

@@ -17,6 +17,7 @@ import { TargetPopulation } from 'vscode-tas-client';
 import * as which from 'which';
 import { logAndReturn } from '../Utility/Async/returns';
 import * as util from '../common';
+import { modelSelector } from '../constants';
 import { getCrashCallStacksChannel } from '../logger';
 import { PlatformInformation } from '../platform';
 import * as telemetry from '../telemetry';
@@ -26,6 +27,7 @@ import { CodeActionDiagnosticInfo, CodeAnalysisDiagnosticIdentifiersAndUri, code
 import { CppBuildTaskProvider } from './cppBuildTaskProvider';
 import { getCustomConfigProviders } from './customProviders';
 import { getLanguageConfig } from './languageConfig';
+import { getLocaleId } from './localization';
 import { PersistentState } from './persistentState';
 import { NodeType, TreeNode } from './referencesModel';
 import { CppSettings } from './settings';
@@ -404,6 +406,7 @@ export function registerCommands(enabled: boolean): void {
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.ExtractToMemberFunction', enabled ? () => onExtractToFunction(false, true) : onDisabledCommand));
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.ExpandSelection', enabled ? (r: Range) => onExpandSelection(r) : onDisabledCommand));
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.getIncludes', enabled ? (maxDepth: number) => getIncludes(maxDepth) : () => Promise.resolve()));
+    commandDisposables.push(vscode.commands.registerCommand('C_Cpp.ShowCopilotHover', enabled ? onCopilotHover : onDisabledCommand));
 }
 
 function onDisabledCommand() {
@@ -1379,3 +1382,88 @@ export async function getIncludes(maxDepth: number): Promise<any> {
     const includes = await clients.ActiveClient.getIncludes(maxDepth);
     return includes;
 }
+
+// This uses several workarounds for interacting with the hover feature.
+// A proposal for dynamic hover content would help, such as the one here (https://github.com/microsoft/vscode/issues/195394)
+async function onCopilotHover(): Promise<void> {
+    if (!vscode.window.activeTextEditor) { return; }
+    // Check if the user has access to vscode language model.
+    const vscodelm = (vscode as any).lm;
+    if (!vscodelm) { return; }
+
+    // Prep hover with wait message and get the hover position location.
+    const copilotHoverResult = await clients.ActiveClient.showCopilotHover('$(loading~spin)');
+    const hoverPosition = new vscode.Position(copilotHoverResult.hoverPos.line, copilotHoverResult.hoverPos.character);
+
+    // Make sure the editor has focus.
+    await vscode.window.showTextDocument(vscode.window.activeTextEditor.document, { preserveFocus: false, selection: new vscode.Selection(hoverPosition, hoverPosition) });
+
+    // Workaround to force the editor to update it's content, needs to be called from another location first.
+    await vscode.commands.executeCommand('cursorMove', { to: 'right' });
+    await vscode.commands.executeCommand('editor.action.showHover', { focus: 'noAutoFocus' });
+
+    // Move back and show the correct hover.
+    await clients.ActiveClient.showCopilotHover('$(loading~spin)');
+    await vscode.commands.executeCommand('cursorMove', { to: 'left' });
+    await vscode.commands.executeCommand('editor.action.showHover', { focus: 'noAutoFocus'});
+
+    // Gather the content for the query from the client.
+    const response = await clients.ActiveClient.getCopilotHoverInfo();
+
+    // Ensure the content is valid before proceeding.
+    const request = response.content;
+
+    if (request.length === 0) {
+        return;
+    }
+
+    const locale = getLocaleId();
+
+    const messages = [
+        vscode.LanguageModelChatMessage
+            .User(request + locale)];
+
+    const [model] = await vscodelm.selectChatModels(modelSelector);
+
+    let chatResponse: vscode.LanguageModelChatResponse | undefined;
+    try {
+        chatResponse = await model.sendRequest(
+            messages,
+            {},
+            new vscode.CancellationTokenSource().token
+        );
+    } catch (err) {
+        if (err instanceof vscode.LanguageModelError) {
+            console.log(err.message, err.code, err.cause);
+        } else {
+            throw err;
+        }
+        return;
+    }
+
+    // Ensure we have a valid response from Copilot.
+    if (!chatResponse) { return; }
+
+    let content: string = '';
+
+    try {
+        for await (const fragment of chatResponse.text) {
+            content += fragment;
+        }
+    } catch (err) {
+        return;
+    }
+
+    if (!vscode.window.activeTextEditor) { return; }
+    await vscode.window.showTextDocument(vscode.window.activeTextEditor.document, { preserveFocus: false, selection: new vscode.Selection(hoverPosition, hoverPosition) });
+
+    // Same workaround as above to force the editor to update it's content.
+    await clients.ActiveClient.showCopilotHover('$(loading~spin)');
+    await vscode.commands.executeCommand('cursorMove', { to: 'right' });
+    await vscode.commands.executeCommand('editor.action.showHover', { focus: 'noAutoFocus'});
+
+    // Prepare and show the real content.
+    await clients.ActiveClient.showCopilotHover(content);
+    await vscode.commands.executeCommand('cursorMove', { to: 'left' });
+    await vscode.commands.executeCommand('editor.action.showHover', { focus: 'noAutoFocus'});
+}

Extension/src/LanguageServer/protocolFilter.ts

@@ -89,7 +89,17 @@ export function createProtocolFilter(): Middleware {
         provideHover: async (document, position, token, next: (document: any, position: any, token: any) => any) => clients.ActiveClient.enqueue(async () => {
             const me: Client = clients.getClientFor(document.uri);
             if (me.TrackedDocuments.has(document.uri.toString())) {
-                return next(document, position, token);
+                // Currently needed to support icons.
+                return next(document, position, token).then((value: vscode.Hover) => {
+                    if (value && value.contents instanceof Array) {
+                        value.contents.forEach((content) => {
+                            if (content instanceof vscode.MarkdownString) {
+                                content.supportThemeIcons = true;
+                            }
+                        });
+                    }
+                    return value;
+                });
             }
             return null;
         }),

Extension/src/LanguageServer/settings.ts

@@ -15,7 +15,7 @@ import * as vscode from 'vscode';
 import * as nls from 'vscode-nls';
 import * as which from 'which';
 import { getCachedClangFormatPath, getCachedClangTidyPath, getExtensionFilePath, getRawSetting, isArray, isArrayOfString, isBoolean, isNumber, isObject, isString, isValidMapping, setCachedClangFormatPath, setCachedClangTidyPath } from '../common';
-import { isWindows } from '../constants';
+import { isWindows, modelSelector } from '../constants';
 import * as telemetry from '../telemetry';
 import { DefaultClient, cachedEditorConfigLookups, cachedEditorConfigSettings, hasTrustedCompilerPaths } from './client';
 import { clients } from './extension';
@@ -162,6 +162,7 @@ export interface SettingsParams {
     codeAnalysisMaxMemory: number | null;
     codeAnalysisUpdateDelay: number;
     workspaceFolderSettings: WorkspaceFolderSettingsParams[];
+    copilotHover: boolean | undefined;
 }
 
 function getTarget(): vscode.ConfigurationTarget {
@@ -462,6 +463,37 @@ export class CppSettings extends Settings {
             && this.intelliSenseEngine === "default"
             && vscode.workspace.getConfiguration("workbench").get<any>("colorTheme") !== "Default High Contrast";
     }
+    public get copilotHover(): PromiseLike<boolean> {
+        // Check if the setting is explicitly set to enabled or disabled.
+        const setting = super.Section.get<string>("copilotHover");
+        if (setting === "disabled") {
+            return Promise.resolve(false);
+        }
+
+        // Check if the user has access to vscode language model.
+        const vscodelm = (vscode as any).lm;
+        if (!vscodelm) {
+            return Promise.resolve(false);
+        }
+
+        // Check if the user has access to Copilot.
+        return vscodelm.selectChatModels(modelSelector).then((models: any[]) => {
+            // If no models are returned, the user currently does not have access.
+            if (models.length === 0) {
+                // Register to update this setting if the user gains access.
+                vscodelm.onDidChangeChatModels(() => {
+                    clients.ActiveClient.sendDidChangeSettings();
+                });
+                return false;
+            }
+
+            if (setting === "enabled") {
+                return true;
+            }
+
+            return telemetry.isFlightEnabled("cpp.copilotHover");
+        });
+    }
     public get formattingEngine(): string { return this.getAsString("formatting"); }
     public get vcFormatIndentBraces(): boolean { return this.getAsBoolean("vcFormat.indent.braces"); }
     public get vcFormatIndentMultiLineRelativeTo(): string { return this.getAsString("vcFormat.indent.multiLineRelativeTo"); }

Extension/src/constants.ts

@@ -13,3 +13,6 @@ export const isLinux = OperatingSystem === 'linux';
 
 // if you want to see the output of verbose logging, set this to true.
 export const verboseEnabled = false;
+
+// Model selector for Copilot features
+export const modelSelector = { vendor: 'copilot', family: 'gpt-4' };

Extension/src/nativeStrings.json

@@ -478,5 +478,6 @@
     "refactor_extract_reference_return_c_code": "The function would have to return a value by reference. C code cannot return references.",
     "refactor_extract_xborder_jump": "Jumps between the selected code and the surrounding code are present.",
     "refactor_extract_missing_return": "In the selected code, some control paths exit without setting the return value. This is supported only for scalar, numeric, and pointer return types.",
-    "expand_selection": "Expand selection (to enable 'Extract to function')"
+    "expand_selection": "Expand selection (to enable 'Extract to function')",
+    "copilot_hover_link": "Generate Copilot summary"
 }

Extension/src/telemetry.ts

@@ -83,6 +83,10 @@ export async function isExperimentEnabled(experimentName: string): Promise<boole
     if (new CppSettings().experimentalFeatures) {
         return true;
     }
+    return isFlightEnabled(experimentName);
+}
+
+export async function isFlightEnabled(experimentName: string): Promise<boolean> {
     const experimentationService: IExperimentationService | undefined = await getExperimentationService();
     const isEnabled: boolean | undefined = experimentationService?.getTreatmentVariable<boolean>("vscode", experimentName);
     return isEnabled ?? false;