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

Extension/package.json

@@ -11,7 +11,7 @@
     },
     "license": "SEE LICENSE IN LICENSE.txt",
     "engines": {
-        "vscode": "^1.67.0"
+        "vscode": "^1.90.0"
     },
     "bugs": {
         "url": "https://github.com/Microsoft/vscode-cpptools/issues",
@@ -3286,6 +3286,17 @@
                         "default": false,
                         "markdownDescription": "%c_cpp.configuration.addNodeAddonIncludePaths.markdownDescription%",
                         "scope": "application"
+                    },
+                    "C_Cpp.onTheFlyDocsEnabled": {
+                        "type": "string",
+                        "enum": [
+                            "default",
+                            "enabled",
+                            "disabled"
+                        ],
+                        "default": "default",
+                        "markdownDescription": "%c_cpp.configuration.otfDocsEnabled.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.otfDocsEnabled.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

@@ -543,6 +543,21 @@ interface GetIncludesResult
     includedFiles: string[];
 }
 
+interface ShowOTFDocsParams
+{
+    content: string;
+}
+
+interface ShowOTFDocsResult
+{
+    hoverPos: Position;
+}
+
+interface GetOTFDocsInfoResult
+{
+    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');
@@ -562,6 +577,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 GetOTFDocsInfoRequest: RequestType<void, GetOTFDocsInfoResult, void> = new RequestType<void, GetOTFDocsInfoResult, void>('cpptools/getOTFDocsInfo');
+const ShowOTFDocsRequest: RequestType<ShowOTFDocsParams, ShowOTFDocsResult, void> = new RequestType<ShowOTFDocsParams, ShowOTFDocsResult, void>('cpptools/showOTFDocs');
 
 // Notifications to the server
 const DidOpenNotification: NotificationType<DidOpenTextDocumentParams> = new NotificationType<DidOpenTextDocumentParams>('textDocument/didOpen');
@@ -792,6 +809,8 @@ export interface Client {
     setShowConfigureIntelliSenseButton(show: boolean): void;
     addTrustedCompiler(path: string): Promise<void>;
     getIncludes(maxDepth: number): Promise<GetIncludesResult>;
+    showOTFDocs(content: string): Promise<ShowOTFDocsResult>;
+    getOTFDocsInfo(): Promise<GetOTFDocsInfoResult>;
 }
 
 export function createClient(workspaceFolder?: vscode.WorkspaceFolder): Client {
@@ -1446,7 +1465,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();
@@ -1472,6 +1491,7 @@ export class DefaultClient implements Client {
             codeAnalysisMaxConcurrentThreads: workspaceSettings.codeAnalysisMaxConcurrentThreads,
             codeAnalysisMaxMemory: workspaceSettings.codeAnalysisMaxMemory,
             codeAnalysisUpdateDelay: workspaceSettings.codeAnalysisUpdateDelay,
+            otfDocsEnabled: await workspaceSettings.otfDocsEnabled,
             workspaceFolderSettings: workspaceFolderSettingsParams
         };
     }
@@ -1541,7 +1561,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);
@@ -1582,6 +1602,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?
@@ -1607,7 +1633,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>> {
@@ -3978,6 +4004,17 @@ export class DefaultClient implements Client {
         compilerDefaults = await this.requestCompiler(path);
         DebugConfigurationProvider.ClearDetectedBuildTasks();
     }
+
+    public async showOTFDocs(content: string): Promise<ShowOTFDocsResult> {
+        const params: ShowOTFDocsParams = {content: content};
+        await this.ready;
+        return this.languageClient.sendRequest(ShowOTFDocsRequest, params);
+    }
+
+    public async getOTFDocsInfo(): Promise<GetOTFDocsInfoResult> {
+        await this.ready;
+        return this.languageClient.sendRequest(GetOTFDocsInfoRequest, null);
+    }
 }
 
 function getLanguageServerFileName(): string {
@@ -4090,4 +4127,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); }
+    showOTFDocs(content: string): Promise<ShowOTFDocsResult> { return Promise.resolve({} as ShowOTFDocsResult); }
+    getOTFDocsInfo(): Promise<GetOTFDocsInfoResult> { return Promise.resolve({} as GetOTFDocsInfoResult); }
 }

Extension/src/LanguageServer/extension.ts

@@ -26,6 +26,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 +405,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.OTFDocs', enabled ? onOTFDocs : onDisabledCommand));
 }
 
 function onDisabledCommand() {
@@ -1379,3 +1381,66 @@ export async function getIncludes(maxDepth: number): Promise<any> {
     const includes = await clients.ActiveClient.getIncludes(maxDepth);
     return includes;
 }
+
+async function onOTFDocs(): Promise<void> {
+    const response = await clients.ActiveClient.getOTFDocsInfo();
+
+    // 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 vscode.lm.selectChatModels({
+        vendor: 'copilot',
+        family: 'gpt-4'
+    });
+
+    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;
+    }
+
+    let content: string = '';
+
+    try {
+        for await (const fragment of chatResponse.text) {
+            content += fragment;
+        }
+    } catch (err) {
+        return;
+    }
+
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+        return;
+    }
+
+    // Prepare the client to show the content on next hover.
+    const result = await clients.ActiveClient.showOTFDocs(content);
+    // Make sure the editor has focus.
+    await vscode.commands.executeCommand('workbench.action.focusActiveEditorGroup');
+    // Move the cursor to the position of the open hover.
+    editor.selection = new vscode.Selection(result.hoverPos.line, result.hoverPos.character, result.hoverPos.line, result.hoverPos.character);
+    // Trigger a hover event to show the new content. This is necessary because the content isn't updated if the hover isn't closed and then reopened.
+    // API proposal to update hover content: "editorHoverVerbosityLevel". (https://github.com/microsoft/vscode/issues/195394)
+    await vscode.commands.executeCommand('editor.action.showHover', { focus: 'noAutoFocus'});
+}

Extension/src/LanguageServer/protocolFilter.ts

@@ -89,7 +89,16 @@ 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);
+                const result: Thenable<vscode.Hover> = next(document, position, token);
+                // Needed to support theme icons in markdown hover content until vscode-languageclient is updated.
+                return result.then((value: vscode.Hover) => {
+                    value.contents.forEach((content) => {
+                        if (content instanceof vscode.MarkdownString) {
+                            content.supportThemeIcons = true;
+                        }
+                    });
+                    return value;
+                });
             }
             return null;
         }),

Extension/src/LanguageServer/settings.ts

@@ -16,6 +16,7 @@ import * as nls from 'vscode-nls';
 import * as which from 'which';
 import { getCachedClangFormatPath, getCachedClangTidyPath, getExtensionFilePath, setCachedClangFormatPath, setCachedClangTidyPath } from '../common';
 import { isWindows } from '../constants';
+import { isFlightEnabled } from '../telemetry';
 import { DefaultClient, cachedEditorConfigLookups, cachedEditorConfigSettings, hasTrustedCompilerPaths } from './client';
 import { clients } from './extension';
 import { CommentPattern } from './languageConfig';
@@ -159,6 +160,7 @@ export interface SettingsParams {
     codeAnalysisMaxMemory: number | null | undefined;
     codeAnalysisUpdateDelay: number | undefined;
     workspaceFolderSettings: WorkspaceFolderSettingsParams[];
+    otfDocsEnabled: boolean | undefined;
 }
 
 function getTarget(): vscode.ConfigurationTarget {
@@ -461,6 +463,33 @@ export class CppSettings extends Settings {
         return super.Section.get<boolean>("inlayHints.referenceOperator.showSpace") === true;
     }
 
+    public get otfDocsEnabled(): PromiseLike<boolean> {
+        // Check if the user has access to copilot.
+        return vscode.lm.selectChatModels({vendor: "copilot"}).then((models) => {
+            // Check if the setting is explicitly set to enabled or disabled.
+            const setting = super.Section.get<string>("onTheFlyDocsEnabled");
+
+            // If no models are returned, the user doesn't have access to copilot.
+            if (models.length === 0) {
+                // Register to update this setting if the user gains access to copilot.
+                vscode.lm.onDidChangeChatModels(() => {
+                    clients.ActiveClient.sendDidChangeSettings();
+                });
+                return false;
+            }
+
+            if (setting === "enabled") {
+                return true;
+            }
+            if (setting === "disabled") {
+                return false;
+            }
+
+            // Check for the feature flag.
+            return isFlightEnabled("cpp.otfDocs");
+        });
+    }
+
     public get enhancedColorization(): boolean {
         return super.Section.get<string>("enhancedColorization")?.toLowerCase() !== "disabled"
             && this.intelliSenseEngine === "default"

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')",
+    "otf_docs_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;