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

Extension/package.json

@@ -3278,6 +3278,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

@@ -768,6 +768,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/Providers/CopilotHoverProvider.ts

@@ -0,0 +1,129 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+import * as vscode from 'vscode';
+import { Position, ResponseError } from 'vscode-languageclient';
+import * as nls from 'vscode-nls';
+import { DefaultClient, GetCopilotHoverInfoParams, GetCopilotHoverInfoRequest } from '../client';
+import { RequestCancelled, ServerCancelled } from '../protocolFilter';
+import { CppSettings } from '../settings';
+
+nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
+const localize: nls.LocalizeFunc = nls.loadMessageBundle();
+
+export class CopilotHoverProvider implements vscode.HoverProvider {
+    private client: DefaultClient;
+    private currentDocument: vscode.TextDocument | undefined;
+    private currentPosition: vscode.Position | undefined;
+    private waiting: boolean = false;
+    private ready: boolean = false;
+    private cancelled: boolean = false;
+    private cancelledDocument: vscode.TextDocument | undefined;
+    private cancelledPosition: vscode.Position | undefined;
+    private content: string | undefined;
+    constructor(client: DefaultClient) {
+        this.client = client;
+    }
+
+    public async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Hover | undefined> {
+        await this.client.ready;
+        const settings: CppSettings = new CppSettings(vscode.workspace.getWorkspaceFolder(document.uri)?.uri);
+        if (settings.hover === "disabled") {
+            return undefined;
+        }
+
+        if (!this.isNewHover(document, position)) {
+            if (this.ready) {
+                const contentMarkdown = new vscode.MarkdownString(`$(sparkle) Copilot\n\n${this.content}`, true);
+                return new vscode.Hover(contentMarkdown);
+            }
+            if (this.waiting) {
+                const loadingMarkdown = new vscode.MarkdownString("$(sparkle) $(loading~spin)", true);
+                return new vscode.Hover(loadingMarkdown);
+            }
+        }
+
+        // Fresh hover, reset state.
+        this.reset();
+        // Wait for the main hover provider to finish and confirm it has content.
+        const hoverProvider = this.client.getHoverProvider();
+        if (!await hoverProvider?.contentReady) {
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            throw new vscode.CancellationError();
+        }
+        this.currentDocument = document;
+        this.currentPosition = position;
+        const commandString = "$(sparkle) [" + localize("generate.copilot.description", "Generate Copilot summary") + "](command:C_Cpp.ShowCopilotHover \"" + localize("copilot.disclaimer", "AI-generated content may be incorrect.") + "\")";
+        const commandMarkdown = new vscode.MarkdownString(commandString);
+        commandMarkdown.supportThemeIcons = true;
+        commandMarkdown.isTrusted = true;
+        return new vscode.Hover(commandMarkdown);
+    }
+
+    public showWaiting(): void {
+        this.waiting = true;
+    }
+
+    public showContent(content: string): void {
+        this.ready = true;
+        this.content = content;
+    }
+
+    public getCurrentHoverDocument(): vscode.TextDocument | undefined {
+        return this.currentDocument;
+    }
+
+    public getCurrentHoverPosition(): vscode.Position | undefined {
+        return this.currentPosition;
+    }
+
+    public async getRequestInfo(document: vscode.TextDocument, position: vscode.Position): Promise<string> {
+        let requestInfo = "";
+        const params: GetCopilotHoverInfoParams = {
+            uri: document.uri.toString(),
+            position: Position.create(position.line, position.character)
+        };
+        await this.client.ready;
+        try {
+            const response = await this.client.languageClient.sendRequest(GetCopilotHoverInfoRequest, params);
+            requestInfo = response.content;
+        } catch (e: any) {
+            if (e instanceof ResponseError && (e.code === RequestCancelled || e.code === ServerCancelled)) {
+                throw new vscode.CancellationError();
+            }
+            throw e;
+        }
+
+        return requestInfo;
+    }
+
+    public isCancelled(document: vscode.TextDocument, position: vscode.Position): boolean {
+        if (this.cancelled && this.cancelledDocument === document && this.cancelledPosition === position) {
+            // Cancellation is being acknowledged.
+            this.cancelled = false;
+            this.cancelledDocument = undefined;
+            this.cancelledPosition = undefined;
+            return true;
+        }
+        return false;
+    }
+
+    private reset(): void {
+        // If there was a previous call, cancel it.
+        if (this.waiting) {
+            this.cancelled = true;
+            this.cancelledDocument = this.currentDocument;
+            this.cancelledPosition = this.currentPosition;
+        }
+        this.waiting = false;
+        this.ready = false;
+        this.content = undefined;
+    }
+
+    private isNewHover(document: vscode.TextDocument, position: vscode.Position): boolean {
+        return !(this.currentDocument === document && this.currentPosition?.line === position.line && (this.currentPosition?.character === position.character || this.currentPosition?.character === position.character - 1));
+    }
+}

Extension/src/LanguageServer/Providers/HoverProvider.ts

@@ -4,17 +4,20 @@
  * ------------------------------------------------------------------------------------------ */
 import * as vscode from 'vscode';
 import { Position, ResponseError, TextDocumentPositionParams } from 'vscode-languageclient';
+import { ManualSignal } from '../../Utility/Async/manualSignal';
 import { DefaultClient, HoverRequest } from '../client';
 import { RequestCancelled, ServerCancelled } from '../protocolFilter';
 import { CppSettings } from '../settings';
 
 export class HoverProvider implements vscode.HoverProvider {
     private client: DefaultClient;
+    private readonly hasContent = new ManualSignal<boolean>(true);
     constructor(client: DefaultClient) {
         this.client = client;
     }
 
     public async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Hover | undefined> {
+        this.hasContent.reset();
         const settings: CppSettings = new CppSettings(vscode.workspace.getWorkspaceFolder(document.uri)?.uri);
         if (settings.hover === "disabled") {
             return undefined;
@@ -52,6 +55,11 @@ export class HoverProvider implements vscode.HoverProvider {
                 hoverResult.range.end.line, hoverResult.range.end.character);
         }
 
+        this.hasContent.resolve(strings.length > 0);
         return new vscode.Hover(strings, range);
     }
+
+    get contentReady(): Promise<boolean> {
+        return this.hasContent;
+    }
 }

Extension/src/LanguageServer/client.ts

@@ -43,6 +43,7 @@ import { localizedStringCount, lookupString } from '../nativeStrings';
 import { SessionState } from '../sessionState';
 import * as telemetry from '../telemetry';
 import { TestHook, getTestHook } from '../testHook';
+import { CopilotHoverProvider } from './Providers/CopilotHoverProvider';
 import { HoverProvider } from './Providers/HoverProvider';
 import {
     CodeAnalysisDiagnosticIdentifiersAndUri,
@@ -533,6 +534,15 @@ export interface GetIncludesResult {
     includedFiles: string[];
 }
 
+export interface GetCopilotHoverInfoParams {
+    uri: string;
+    position: Position;
+}
+
+interface GetCopilotHoverInfoResult {
+    content: string;
+}
+
 export interface ChatContextResult {
     language: string;
     standardVersion: string;
@@ -554,6 +564,7 @@ export const FormatDocumentRequest: RequestType<FormatParams, FormatResult, void
 export const FormatRangeRequest: RequestType<FormatParams, FormatResult, void> = new RequestType<FormatParams, FormatResult, void>('cpptools/formatRange');
 export const FormatOnTypeRequest: RequestType<FormatParams, FormatResult, void> = new RequestType<FormatParams, FormatResult, void>('cpptools/formatOnType');
 export const HoverRequest: RequestType<TextDocumentPositionParams, vscode.Hover, void> = new RequestType<TextDocumentPositionParams, vscode.Hover, void>('cpptools/hover');
+export const GetCopilotHoverInfoRequest: RequestType<GetCopilotHoverInfoParams, GetCopilotHoverInfoResult, void> = new RequestType<GetCopilotHoverInfoParams, GetCopilotHoverInfoResult, void>('cpptools/getCopilotHoverInfo');
 const CreateDeclarationOrDefinitionRequest: RequestType<CreateDeclarationOrDefinitionParams, CreateDeclarationOrDefinitionResult, void> = new RequestType<CreateDeclarationOrDefinitionParams, CreateDeclarationOrDefinitionResult, void>('cpptools/createDeclDef');
 const ExtractToFunctionRequest: RequestType<ExtractToFunctionParams, WorkspaceEditResult, void> = new RequestType<ExtractToFunctionParams, WorkspaceEditResult, void>('cpptools/extractToFunction');
 const GoToDirectiveInGroupRequest: RequestType<GoToDirectiveInGroupParams, Position | undefined, void> = new RequestType<GoToDirectiveInGroupParams, Position | undefined, void>('cpptools/goToDirectiveInGroup');
@@ -790,6 +801,7 @@ export interface Client {
     getShowConfigureIntelliSenseButton(): boolean;
     setShowConfigureIntelliSenseButton(show: boolean): void;
     addTrustedCompiler(path: string): Promise<void>;
+    getCopilotHoverProvider(): CopilotHoverProvider | undefined;
     getIncludes(maxDepth: number, token: vscode.CancellationToken): Promise<GetIncludesResult>;
     getChatContext(token: vscode.CancellationToken): Promise<ChatContextResult>;
 }
@@ -824,11 +836,14 @@ export class DefaultClient implements Client {
     private settingsTracker: SettingsTracker;
     private loggingLevel: number = 1;
     private configurationProvider?: string;
+    private hoverProvider: HoverProvider | undefined;
+    private copilotHoverProvider: CopilotHoverProvider | undefined;
 
     public lastCustomBrowseConfiguration: PersistentFolderState<WorkspaceBrowseConfiguration | undefined> | undefined;
     public lastCustomBrowseConfigurationProviderId: PersistentFolderState<string | undefined> | undefined;
     public lastCustomBrowseConfigurationProviderVersion: PersistentFolderState<Version> | undefined;
     public currentCaseSensitiveFileSupport: PersistentWorkspaceState<boolean> | undefined;
+    public currentCopilotHoverEnabled: PersistentWorkspaceState<string> | undefined;
     private registeredProviders: PersistentFolderState<string[]> | undefined;
 
     private configStateReceived: ConfigStateReceived = { compilers: false, compileCommands: false, configProviders: undefined, timeout: false };
@@ -1257,8 +1272,16 @@ export class DefaultClient implements Client {
                 this.registerFileWatcher();
                 initializedClientCount = 0;
                 this.inlayHintsProvider = new InlayHintsProvider();
+                this.hoverProvider = new HoverProvider(this);
 
-                this.disposables.push(vscode.languages.registerHoverProvider(util.documentSelector, new HoverProvider(this)));
+                const settings: CppSettings = new CppSettings();
+                this.currentCopilotHoverEnabled = new PersistentWorkspaceState<string>("cpp.copilotHover", settings.copilotHover);
+                if (settings.copilotHover === "enabled" ||
+                    (settings.copilotHover === "default" && await telemetry.isFlightEnabled("cpp.copilotHover"))) {
+                    this.copilotHoverProvider = new CopilotHoverProvider(this);
+                    this.disposables.push(vscode.languages.registerHoverProvider(util.documentSelector, this.copilotHoverProvider));
+                }
+                this.disposables.push(vscode.languages.registerHoverProvider(util.documentSelector, this.hoverProvider));
                 this.disposables.push(vscode.languages.registerInlayHintsProvider(util.documentSelector, this.inlayHintsProvider));
                 this.disposables.push(vscode.languages.registerRenameProvider(util.documentSelector, new RenameProvider(this)));
                 this.disposables.push(vscode.languages.registerReferenceProvider(util.documentSelector, new FindAllReferencesProvider(this)));
@@ -1276,7 +1299,6 @@ export class DefaultClient implements Client {
                 this.codeFoldingProvider = new FoldingRangeProvider(this);
                 this.codeFoldingProviderDisposable = vscode.languages.registerFoldingRangeProvider(util.documentSelector, this.codeFoldingProvider);
 
-                const settings: CppSettings = new CppSettings();
                 if (settings.isEnhancedColorizationEnabled && semanticTokensLegend) {
                     this.semanticTokensProvider = new SemanticTokensProvider();
                     this.semanticTokensProviderDisposable = vscode.languages.registerDocumentSemanticTokensProvider(util.documentSelector, this.semanticTokensProvider, semanticTokensLegend);
@@ -1451,6 +1473,9 @@ export class DefaultClient implements Client {
         if (this.currentCaseSensitiveFileSupport && workspaceSettings.isCaseSensitiveFileSupportEnabled !== this.currentCaseSensitiveFileSupport.Value) {
             void util.promptForReloadWindowDueToSettingsChange();
         }
+        if (this.currentCopilotHoverEnabled && workspaceSettings.copilotHover !== this.currentCopilotHoverEnabled.Value) {
+            void util.promptForReloadWindowDueToSettingsChange();
+        }
         return {
             filesAssociations: workspaceOtherSettings.filesAssociations,
             workspaceFallbackEncoding: workspaceOtherSettings.filesEncoding,
@@ -1473,6 +1498,7 @@ export class DefaultClient implements Client {
             codeAnalysisMaxConcurrentThreads: workspaceSettings.codeAnalysisMaxConcurrentThreads,
             codeAnalysisMaxMemory: workspaceSettings.codeAnalysisMaxMemory,
             codeAnalysisUpdateDelay: workspaceSettings.codeAnalysisUpdateDelay,
+            copilotHover: workspaceSettings.copilotHover,
             workspaceFolderSettings: workspaceFolderSettingsParams
         };
     }
@@ -1583,6 +1609,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?
@@ -4007,6 +4039,19 @@ export class DefaultClient implements Client {
         compilerDefaults = await this.requestCompiler(path);
         DebugConfigurationProvider.ClearDetectedBuildTasks();
     }
+
+    public getHoverProvider(): HoverProvider | undefined {
+        return this.hoverProvider;
+    }
+
+    public getCopilotHoverProvider(): CopilotHoverProvider | undefined {
+        return this.copilotHoverProvider;
+    }
+
+    public async getCopilotHoverInfo(): Promise<GetCopilotHoverInfoResult> {
+        await this.ready;
+        return this.languageClient.sendRequest(GetCopilotHoverInfoRequest, null);
+    }
 }
 
 function getLanguageServerFileName(): string {
@@ -4118,6 +4163,8 @@ class NullClient implements Client {
     getShowConfigureIntelliSenseButton(): boolean { return false; }
     setShowConfigureIntelliSenseButton(show: boolean): void { }
     addTrustedCompiler(path: string): Promise<void> { return Promise.resolve(); }
+    getCopilotHoverProvider(): CopilotHoverProvider | undefined { return undefined; }
+    getCopilotHoverInfo(): Promise<GetCopilotHoverInfoResult> { return Promise.resolve({} as GetCopilotHoverInfoResult); }
     getIncludes(maxDepth: number, token: vscode.CancellationToken): Promise<GetIncludesResult> { return Promise.resolve({} as GetIncludesResult); }
     getChatContext(token: vscode.CancellationToken): Promise<ChatContextResult> { return Promise.resolve({} as ChatContextResult); }
 }