extension/src/language: create interactive list enum middleware

The interactive language client accept an interactive middleware
as input. The interactive middleware allow the extension developer
to specify middleware for interactive list enum request.

By default (if middleware not provided), the client call the
default "next" function. Otherwise (if provided), the client
pass the "parameter" and the "next" function which allows the
caller to decide whether / how the caller want to call the
"next" function.

The pattern looks very similar to vscode-languageserver-node
https://github.com/microsoft/vscode-languageserver-node/blob/main/client/src/common/documentHighlight.ts

Example & validation: CL 781460

For golang/go#76331

Change-Id: I124ad8681bd6b926be4e517ef563832a6eb59440
Reviewed-on: https://go-review.googlesource.com/c/vscode-go/+/781221
LUCI-TryBot-Result: golang-scoped@luci-project-accounts.iam.gserviceaccount.com <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Madeline Kalil <mkalil@google.com>

Author: h9jiang

extension/src/language/form.ts

@@ -6,7 +6,13 @@
 
 import * as vscode from 'vscode';
 import { InitializeParams } from 'vscode-languageserver-protocol';
-import { LanguageClient, RequestType, ServerOptions, LanguageClientOptions } from 'vscode-languageclient/node';
+import {
+	LanguageClient,
+	RequestType,
+	ServerOptions,
+	LanguageClientOptions,
+	Middleware
+} from 'vscode-languageclient/node';
 
 // ----------------------------------------------------------------------------
 // Form Field Type Definitions
@@ -283,12 +289,42 @@ export interface InteractiveListEnumParams {
 	query: string;
 }
 
+/**
+ * InteractiveLanguageClientOptions extends LanguageClientOptions with
+ * interactive middleware support.
+ */
+export interface InteractiveLanguageClientOptions extends LanguageClientOptions {
+	middleware?: InteractiveMiddleware;
+}
+
+/**
+ * InteractiveMiddleware extends the standard Language Server Protocol (LSP)
+ * `Middleware` to support interactive refactoring workflows.
+ *
+ * This allows extension authors to intercept key lifecycle events of the
+ * interactive dialog, including the command resolution phase, the execution of
+ * the validated command, and dynamic enumeration requests for lazy-loaded options.
+ */
+export type InteractiveMiddleware = Middleware & InteractiveListEnumMiddleware;
+
+export interface InteractiveListEnumSignature {
+	(this: void, param: InteractiveListEnumParams): vscode.ProviderResult<FormEnumEntry[]>;
+}
+
+export interface InteractiveListEnumMiddleware {
+	interactiveListEnum?: (
+		this: void,
+		param: InteractiveListEnumParams,
+		next: InteractiveListEnumSignature
+	) => vscode.ProviderResult<FormEnumEntry[]>;
+}
+
 export class InteractiveLanguageClient extends LanguageClient {
 	constructor(
 		id: string,
 		name: string,
 		serverOptions: ServerOptions,
-		clientOptions: LanguageClientOptions,
+		clientOptions: InteractiveLanguageClientOptions,
 		forceDebug?: boolean
 	) {
 		super(id, name, serverOptions, clientOptions, forceDebug);
@@ -405,14 +441,35 @@ export class InteractiveLanguageClient extends LanguageClient {
 		});
 	}
 
-	// Queries the language server to dynamically retrieve enumeration entries for
-	// interactive form fields of type 'lazyEnum'.
-	async InteractiveListEnum(param: InteractiveListEnumParams): Promise<FormEnumEntry[] | undefined> {
-		const requestType = new RequestType<InteractiveListEnumParams, FormEnumEntry[], void>('interactive/listEnum');
-		return this.sendRequest<FormEnumEntry[]>('interactive/listEnum', param).then(undefined, (error) => {
-			return this.handleFailedRequest(requestType, undefined, error, undefined);
-		});
-	}
+	/**
+	 * Queries the language server to dynamically retrieve enumeration entries for
+	 * interactive form fields of type 'lazyEnum'.
+	 *
+	 * This field uses an arrow function to preserve the lexical `this` context of
+	 * the client. It routes the query through the `interactiveListEnum`
+	 * middleware hook if registered, falling back to the default
+	 * `'interactive/listEnum'` LSP request.
+	 *
+	 * @param param The query parameters, including the data source name, static
+	 * config, and filter string.
+	 * @returns A provider result resolving to the matching list of form
+	 * enumeration entries.
+	 */
+	private interactiveListEnum = (param: InteractiveListEnumParams): vscode.ProviderResult<FormEnumEntry[]> => {
+		const _interactiveListEnum: InteractiveListEnumSignature = (param) => {
+			const requestType = new RequestType<InteractiveListEnumParams, FormEnumEntry[], void>(
+				'interactive/listEnum'
+			);
+			return this.sendRequest<FormEnumEntry[]>('interactive/listEnum', param).then(undefined, (error) => {
+				return this.handleFailedRequest(requestType, undefined, error, undefined);
+			});
+		};
+
+		const middleware = this.clientOptions.middleware as InteractiveMiddleware | undefined;
+		return middleware?.interactiveListEnum
+			? middleware.interactiveListEnum(param, _interactiveListEnum)
+			: _interactiveListEnum(param);
+	};
 
 	/**
 	 * Iterates through the provided form fields and prompts the user for input
@@ -483,7 +540,7 @@ export class InteractiveLanguageClient extends LanguageClient {
 						config: config,
 						query: query
 					};
-					const response = await this.InteractiveListEnum(params);
+					const response = await this.interactiveListEnum(params);
 
 					if (!response) {
 						quickPick.items = [];

extension/src/language/goLanguageServer.ts

@@ -69,7 +69,7 @@ import { GoDocumentSelector } from '../goMode';
 import { COMMAND as GOPLS_ADD_TEST_COMMAND } from '../goGenerateTests';
 import { COMMAND as GOPLS_MODIFY_TAGS_COMMAND } from '../goModifytags';
 import { TelemetryKey, telemetryReporter } from '../goTelemetry';
-import { InteractiveExecuteCommandParams, InteractiveLanguageClient } from './form';
+import { InteractiveExecuteCommandParams, InteractiveLanguageClient, InteractiveMiddleware } from './form';
 
 export interface LanguageServerConfig {
 	serverName: string;
@@ -839,7 +839,7 @@ export async function buildLanguageClient(
 						return null;
 					}
 				}
-			}
+			} as InteractiveMiddleware
 		} as LanguageClientOptions,
 		onDidChangeVulncheckResultEmitter
 	);