feat(gopls): add includes/excludes filter for implementation/reference api

Author: 7sunarni

extension/package.json

@@ -2615,6 +2615,30 @@
           "type": "boolean",
           "markdownDescription": "`\"rangeVariableTypes\"` controls inlay hints for variable types in range statements:\n```go\n\tfor k/* int*/, v/* string*/ := range []string{} {\n\t\tfmt.Println(k, v)\n\t}\n```\n",
           "default": false
+        },
+        "go.implementation": {
+          "filesInclude": {
+            "type": "string",
+            "description": "files want to include in the implementation search.\n",
+            "scope": "resource"
+          },
+          "filesExclude": {
+            "type": "string",
+            "description": "files not want to include in the implementation search.\n",
+            "scope": "resource"
+          }
+        },
+        "go.reference": {
+          "filesInclude": {
+            "type": "string",
+            "description": "files want to include in the implementation search.\n",
+            "scope": "resource"
+          },
+          "filesExclude": {
+            "type": "string",
+            "description": "files not want to include in the implementation search.\n",
+            "scope": "resource"
+          }
         }
       }
     },

extension/src/goImplementation.ts

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------
+ * Copyright 2022 The Go Authors. All rights reserved.
+ * Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------*/
+
+import vscode = require('vscode');
+import { ImplementationRequest } from 'vscode-languageserver-protocol';
+import { GoExtensionContext } from './context';
+import { getGoConfig } from './config';
+import * as glob from './common/glob.js';
+
+
+
+export function GoImplementationProvider(
+	goCtx: GoExtensionContext,
+	includeImports?: boolean
+): GoplsImplementationProvider {
+	return new GoplsImplementationProvider(goCtx, includeImports);
+}
+
+export class GoplsImplementationProvider implements vscode.ImplementationProvider {
+	constructor(private readonly goCtx: GoExtensionContext, private includeImports?: boolean) { }
+	public async provideImplementation(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken):
+		Promise<vscode.Definition | vscode.LocationLink[] | null | undefined> {
+		const { languageClient, serverInfo } = this.goCtx;
+		if (!languageClient) {
+			return [];
+		}
+		const params = languageClient.code2ProtocolConverter.asTextDocumentPositionParams(document, position);
+		return languageClient.sendRequest(ImplementationRequest.type, params, token).then((result) => {
+			if (token.isCancellationRequested) {
+				return null;
+			}
+			const ret = languageClient.protocol2CodeConverter.asDefinitionResult(result, token);
+			const implementationConfig = getGoConfig()['implementation'];
+			let include = "";
+			let exclude = "";
+			if (implementationConfig) {
+				include = implementationConfig["filesInclude"] as string;
+				exclude = implementationConfig["filesExclude"] as string;
+			}
+			return ret.then((data) => {
+				if (data) {
+					const rawLinks = data as vscode.Location[];
+					return filter(rawLinks, include, exclude);
+				}
+			});
+		}, (error) => {
+			return languageClient.handleFailedRequest(ImplementationRequest.type, token, error, null);
+		});
+
+
+
+		function filter(links: vscode.Location[], include: string, exclude: string,): vscode.Location[] {
+			const ret = links.filter(item => {
+				let matches = true;
+				if (include && include !== '') {
+					matches = glob.match(include, item.uri.toString());
+				}
+
+				let doesNotMatch = true;
+				if (exclude && exclude !== '') {
+					doesNotMatch = !glob.match(exclude, item.uri.toString());
+				}
+				return matches && doesNotMatch;
+			});
+
+			return ret;
+		}
+	}
+
+	static activate(ctx: vscode.ExtensionContext, goCtx: GoExtensionContext) {
+		let languageClient = goCtx.languageClient;
+		if (languageClient) {
+			languageClient.middleware.provideImplementation = new GoplsImplementationProvider(goCtx, true).provideImplementation;
+		}
+		vscode.languages.registerImplementationProvider('go', new GoplsImplementationProvider(goCtx, true))
+	}
+
+}

extension/src/goMain.ts

@@ -74,6 +74,8 @@ import { toggleVulncheckCommandFactory } from './goVulncheck';
 import { GoTaskProvider } from './goTaskProvider';
 import { setTelemetryEnvVars, telemetryReporter } from './goTelemetry';
 import { experiments } from './experimental';
+import { GoplsImplementationProvider } from './goImplementation';
+import { GoplsReferenceProvider } from './goReference';
 
 const goCtx: GoExtensionContext = {};
 
@@ -149,6 +151,9 @@ export async function activate(ctx: vscode.ExtensionContext): Promise<ExtensionA
 	GoDebugConfigurationProvider.activate(ctx, goCtx);
 	GoDebugFactory.activate(ctx, goCtx);
 	experiments.activate(ctx);
+	GoplsImplementationProvider.activate(ctx, goCtx);
+	GoplsReferenceProvider.activate(ctx, goCtx);
+
 	GoTestExplorer.setup(ctx, goCtx);
 	GoExplorerProvider.setup(ctx);
 

extension/src/goReference.ts

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------
+ * Copyright 2022 The Go Authors. All rights reserved.
+ * Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------*/
+
+import vscode = require('vscode');
+import { ReferencesRequest } from 'vscode-languageserver-protocol';
+import { GoExtensionContext } from './context';
+import { getGoConfig } from './config';
+import * as glob from './common/glob.js';
+
+
+export function GoImplementationProvider(
+	goCtx: GoExtensionContext,
+	includeImports?: boolean
+): GoplsReferenceProvider {
+	return new GoplsReferenceProvider(goCtx, includeImports);
+}
+
+export class GoplsReferenceProvider implements vscode.ReferenceProvider {
+	constructor(private readonly goCtx: GoExtensionContext, private includeImports?: boolean) { }
+
+	public provideReferences(document: vscode.TextDocument, position: vscode.Position, context: vscode.ReferenceContext, token: vscode.CancellationToken): vscode.ProviderResult<vscode.Location[]> {
+		{
+			const { languageClient, serverInfo } = this.goCtx;
+			if (!languageClient) {
+				return [];
+			}
+
+			const params = languageClient.code2ProtocolConverter.asReferenceParams(document, position,context);
+			return languageClient.sendRequest(ReferencesRequest.type, params, token).then((result) => {
+				if (token.isCancellationRequested) {
+					return null;
+				}
+				const ret = languageClient.protocol2CodeConverter.asDefinitionResult(result, token);
+				const referenceConfig = getGoConfig()['reference'];
+				let include = "";
+				let exclude = "";
+				if (referenceConfig){
+					include = referenceConfig["filesInclude"] as string;
+					exclude = referenceConfig["filesExclude"] as string;
+				}
+				
+				return ret.then((data) => {
+					if (data) {
+						const rawLinks = data as vscode.Location[];
+						return filter(rawLinks, include, exclude);
+					}
+				});
+			}, (error) => {
+				return languageClient.handleFailedRequest(ReferencesRequest.type, token, error, null);
+			});
+
+
+
+			function filter(links: vscode.Location[], include: string, exclude: string,): vscode.Location[] {
+				const ret = links.filter(item => {
+					let matches = true;
+					if (include && include !== '') {
+						matches = glob.match(include, item.uri.toString());
+					}
+
+					let doesNotMatch = true;
+					if (exclude && exclude !== '') {
+						doesNotMatch = !glob.match(exclude, item.uri.toString());
+					}
+					return matches && doesNotMatch;
+				});
+
+				return ret;
+			}
+		}
+
+	}
+	static activate(ctx: vscode.ExtensionContext, goCtx: GoExtensionContext) {
+		let languageClient = goCtx.languageClient;
+		if (languageClient) {
+			languageClient.middleware.provideReferences = new GoplsReferenceProvider(goCtx, true).provideReferences;
+		}
+		vscode.languages.registerReferenceProvider('go', new GoplsReferenceProvider(goCtx, true))
+	}
+
+}