Add logic to infer path

Author: quoctruong

src/debugAdapter/goDebug.ts

@@ -4,8 +4,10 @@
  *--------------------------------------------------------*/
 
 import { ChildProcess, execFile, execSync, spawn, spawnSync } from 'child_process';
+import { EventEmitter } from 'events';
 import * as fs from 'fs';
 import { existsSync, lstatSync } from 'fs';
+import * as glob from 'glob';
 import { Client, RPCConnection } from 'json-rpc2';
 import * as os from 'os';
 import * as path from 'path';
@@ -88,6 +90,20 @@ interface DebuggerState {
 	Running: boolean;
 }
 
+interface PackageBuildInfo {
+	ImportPath: string;
+	DirectoryPath: string;
+	Files: string[];
+}
+
+interface ListPackagesBuildInfoOut {
+	List: PackageBuildInfo[];
+}
+
+interface ListSourcesOut {
+	Sources: string[];
+}
+
 interface CreateBreakpointOut {
 	Breakpoint: DebugBreakpoint;
 }
@@ -319,6 +335,10 @@ function normalizePath(filePath: string) {
 	return filePath;
 }
 
+function getBaseName(filePath: string) {
+	return filePath.includes('/') ? path.basename(filePath) : path.win32.basename(filePath);
+}
+
 class Delve {
 	public program: string;
 	public remotePath: string;
@@ -729,6 +749,9 @@ class GoDebugSession extends LoggingDebugSession {
 	private stopOnEntry: boolean;
 	private logLevel: Logger.LogLevel = Logger.LogLevel.Error;
 	private readonly initdone = 'initdone·';
+	private remoteSourcesAndPackages = new RemoteSourcesAndPackages();
+	private localToRemotePathMapping = new Map<string, string>();
+	private remoteToLocalPathMapping = new Map<string, string>();
 
 	private showGlobalVariables: boolean = false;
 
@@ -827,19 +850,194 @@ class GoDebugSession extends LoggingDebugSession {
 		}
 	}
 
-	protected toDebuggerPath(filePath: string): string {
+	/**
+	 * Given a potential list of paths in potentialPaths array, we will
+	 * find the path that has the longest suffix matching filePath.
+	 * For example, if filePath is /usr/local/foo/bar/main.go
+	 * and potentialPaths are abc/xyz/main.go, bar/main.go
+	 * then bar/main.go will be the result.
+	 */
+	protected findPathWithBestMatchingSuffix(filePath: string, potentialPaths: string[]) {
+		if (!potentialPaths.length) {
+			return;
+		}
+
+		if (potentialPaths.length === 1) {
+			return potentialPaths[0];
+		}
+
+		const filePathSegments = filePath.split(/\/|\\/).reverse();
+		let bestPathSoFar = potentialPaths[0];
+		let bestSegmentsCount = 0;
+		for (const potentialPath of potentialPaths) {
+			const potentialPathSegments = potentialPath.split(/\/|\\/).reverse();
+			let i = 0;
+			for (; i < filePathSegments.length
+					&& i < potentialPathSegments.length
+					&& filePathSegments[i] === potentialPathSegments[i]; i++) {
+				if (i > bestSegmentsCount) {
+					bestSegmentsCount = i;
+					bestPathSoFar = potentialPath;
+				}
+			}
+		}
+		return bestPathSoFar;
+	}
+
+	/**
+	 * Given a local path, try to find matching file in the remote machine
+	 * using remote sources and remote packages info that we get from Delve.
+	 * The result would be cached in localToRemotePathMapping.
+	 */
+	protected inferRemotePathFromLocalPath(localPath: string): string|undefined {
+		if (this.localToRemotePathMapping.has(localPath)) {
+			return this.localToRemotePathMapping.get(localPath);
+		}
+
+		const fileName = getBaseName(localPath);
+		const potentialMatchingRemoteFiles = this.remoteSourcesAndPackages.remoteSourceFilesNameGrouping.get(fileName);
+		const bestMatchingRemoteFile = this.findPathWithBestMatchingSuffix(localPath, potentialMatchingRemoteFiles);
+		if (!bestMatchingRemoteFile) {
+			return;
+		}
+
+		this.localToRemotePathMapping.set(localPath, bestMatchingRemoteFile);
+		return bestMatchingRemoteFile;
+	}
+
+	protected async toDebuggerPath(filePath: string): Promise<string> {
 		if (this.delve.remotePath.length === 0) {
+			if (this.delve.isRemoteDebugging) {
+				// The user trusts us to infer the remote path mapping!
+				try {
+					await this.initializeRemotePackagesAndSources();
+					const matchedRemoteFile = this.inferRemotePathFromLocalPath(filePath);
+					if (matchedRemoteFile) {
+						return matchedRemoteFile;
+					}
+				} catch (error) {
+					log(`Failing to initialize remote sources: ${error}`);
+				}
+			}
 			return this.convertClientPathToDebugger(filePath);
 		}
+
 		// The filePath may have a different path separator than the localPath
 		// So, update it to use the same separator as the remote path to ease
 		// in replacing the local path in it with remote path
 		filePath = filePath.replace(/\/|\\/g, this.remotePathSeparator);
 		return filePath.replace(this.delve.program.replace(/\/|\\/g, this.remotePathSeparator), this.delve.remotePath);
 	}
 
+	/**
+	 * Given a remote path, try to infer the matching local path.
+	 * We attempt to find the path in local Go packages as well as workspaceFolder.
+	 * Cache the result in remoteToLocalPathMapping.
+	 */
+	protected inferLocalPathFromRemotePath(remotePath: string): string|undefined {
+		if (this.remoteToLocalPathMapping.has(remotePath)) {
+			return this.remoteToLocalPathMapping.get(remotePath);
+		}
+
+		const convertedLocalPackageFile = this.inferLocalPathFromRemoteGoPackage(remotePath);
+		if (convertedLocalPackageFile) {
+			this.remoteToLocalPathMapping.set(remotePath, convertedLocalPackageFile);
+			return convertedLocalPackageFile;
+		}
+
+		// If we cannot find the path in packages, most likely it will be in the current directory.
+		const fileName = getBaseName(remotePath);
+		const globSync = glob.sync(fileName, {matchBase: true,
+			cwd: this.delve.program });
+		const bestMatchingLocalPath = this.findPathWithBestMatchingSuffix(remotePath, globSync);
+		if (bestMatchingLocalPath) {
+			const fullLocalPath = path.join(this.delve.program, bestMatchingLocalPath);
+			this.remoteToLocalPathMapping.set(remotePath, fullLocalPath);
+			return fullLocalPath;
+		}
+	}
+
+	/**
+	 * Given a remote path, we attempt to infer the local path by first checking
+	 * if it is in any remote packages. If so, then we attempt to find the matching
+	 * local package and find the local path from there.
+	 */
+	protected inferLocalPathFromRemoteGoPackage(remotePath: string): string|undefined {
+		const remotePackage = this.remoteSourcesAndPackages.remotePackagesBuildInfo.find(
+			(buildInfo) => remotePath.startsWith(buildInfo.DirectoryPath));
+		// Since we know pathToConvert exists in a remote package, we can try to find
+		// that same package in the local client. We can use import path to search for the package.
+		if (!remotePackage) {
+			return;
+		}
+
+		if (!this.remotePathSeparator) {
+			this.remotePathSeparator = findPathSeparator(remotePackage.DirectoryPath);
+		}
+
+		// The remotePackage.DirectoryPath should be something like
+		// <gopath|goroot|source>/<import-path>/xyz...
+		// Directory Path can be like "/go/pkg/mod/github.com/google/[email protected]/cmp"
+		// and Import Path can be like "github.com/google/go-cmp/cmp"
+		const importPathIndex = remotePackage.DirectoryPath.replace(/@v(\d+\.)*(\d+)*/, '')
+			.indexOf(remotePackage.ImportPath);
+		if (importPathIndex < 0) {
+			return;
+		}
+
+		const localRelativeDirectoryPath = remotePackage.DirectoryPath
+			.substr(importPathIndex)
+			.split(this.remotePathSeparator)
+			.join(this.localPathSeparator);
+
+		// Scenario 1: The package is inside the current working directory.
+		const localWorkspacePath = path.join(this.delve.program, localRelativeDirectoryPath);
+		if (fs.existsSync(localWorkspacePath)) {
+			return path.join(this.delve.program,
+				remotePath
+					.substr(importPathIndex)
+					.split(this.remotePathSeparator)
+					.join(this.localPathSeparator));
+		}
+
+		// Scenario 2: The package is inside GOPATH.
+		const pathToConvertWithLocalSeparator = remotePath.split(this.remotePathSeparator).join(this.localPathSeparator);
+		const indexGoModCache = pathToConvertWithLocalSeparator.indexOf(
+			`${this.localPathSeparator}pkg${this.localPathSeparator}mod${this.localPathSeparator}`
+		);
+		const gopath = (process.env['GOPATH'] || '').split(path.delimiter)[0];
+		const localGoPathImportPath = path.join(
+			gopath,
+			pathToConvertWithLocalSeparator.substr(indexGoModCache));
+		if (fs.existsSync(localGoPathImportPath)) {
+			return localGoPathImportPath;
+		}
+
+		// Scenario 3: The package is inside GOROOT.
+		const srcIndex = pathToConvertWithLocalSeparator.indexOf(`${this.localPathSeparator}src${this.localPathSeparator}`);
+		const goroot = process.env['GOROOT'];
+		const localGoRootImportPath = path.join(
+			goroot,
+			pathToConvertWithLocalSeparator
+				.substr(srcIndex));
+		if (fs.existsSync(localGoRootImportPath)) {
+			return localGoRootImportPath;
+		}
+	}
+
+	/**
+	 * This functions assumes that remote packages and paths information
+	 * have been initialized.
+	 */
 	protected toLocalPath(pathToConvert: string): string {
 		if (this.delve.remotePath.length === 0) {
+			// User trusts use to infer the path
+			if (this.delve.isRemoteDebugging) {
+				const inferredPath = this.inferLocalPathFromRemotePath(pathToConvert);
+				if (inferredPath) {
+					return inferredPath;
+				}
+			}
 			return this.convertDebuggerPathToClient(pathToConvert);
 		}
 
@@ -968,7 +1166,7 @@ class GoDebugSession extends LoggingDebugSession {
 		this.delve.call<DebugLocation[] | StacktraceOut>(
 			this.delve.isApiV1 ? 'StacktraceGoroutine' : 'Stacktrace',
 			[stackTraceIn],
-			(err, out) => {
+			async (err, out) => {
 				if (err) {
 					this.logDelveError(err, 'Failed to produce stacktrace');
 					return this.sendErrorResponse(response, 2004, 'Unable to produce stack trace: "{e}"', {
@@ -977,6 +1175,9 @@ class GoDebugSession extends LoggingDebugSession {
 				}
 				const locations = this.delve.isApiV1 ? <DebugLocation[]>out : (<StacktraceOut>out).Locations;
 				log('locations', locations);
+
+				await this.initializeRemotePackagesAndSources();
+
 				let stackFrames = locations.map((location, frameId) => {
 					const uniqueStackFrameId = this.stackFrameHandles.create([goroutineId, frameId]);
 					return new StackFrame(
@@ -1400,8 +1601,8 @@ class GoDebugSession extends LoggingDebugSession {
 			args.remotePath = '';
 		}
 
+		this.localPathSeparator = findPathSeparator(localPath);
 		if (args.remotePath.length > 0) {
-			this.localPathSeparator = findPathSeparator(localPath);
 			this.remotePathSeparator = findPathSeparator(args.remotePath);
 
 			const llist = localPath.split(/\/|\\/).reverse();
@@ -1476,15 +1677,38 @@ class GoDebugSession extends LoggingDebugSession {
 		);
 	}
 
-	private setBreakPoints(
+	/**
+	 * Initializing remote packages and sources.
+	 * We use event model to prevent race conditions.
+	 */
+	private async initializeRemotePackagesAndSources(): Promise<void> {
+		if (this.remoteSourcesAndPackages.initializedRemoteSourceFiles) {
+			return;
+		}
+
+		if (!this.remoteSourcesAndPackages.initializingRemoteSourceFiles) {
+			await this.remoteSourcesAndPackages.initializeRemotePackagesAndSources(this.delve);
+			return;
+		}
+
+		if (this.remoteSourcesAndPackages.initializingRemoteSourceFiles) {
+			await new Promise((resolve) => {
+				this.remoteSourcesAndPackages.on(RemoteSourcesAndPackages.INITIALIZED, () => {
+					resolve();
+				});
+			});
+		}
+	}
+
+	private async setBreakPoints(
 		response: DebugProtocol.SetBreakpointsResponse,
 		args: DebugProtocol.SetBreakpointsArguments
-	): Thenable<void> {
+	): Promise<void> {
 		const file = normalizePath(args.source.path);
 		if (!this.breakpoints.get(file)) {
 			this.breakpoints.set(file, []);
 		}
-		const remoteFile = this.toDebuggerPath(file);
+		const remoteFile = await this.toDebuggerPath(file);
 
 		return Promise.all(
 			this.breakpoints.get(file).map((existingBP) => {
@@ -1591,12 +1815,13 @@ class GoDebugSession extends LoggingDebugSession {
 			);
 	}
 
-	private getPackageInfo(debugState: DebuggerState): Thenable<string> {
+	private async getPackageInfo(debugState: DebuggerState): Promise<string> {
 		if (!debugState.currentThread || !debugState.currentThread.file) {
 			return Promise.resolve(null);
 		}
+		await this.initializeRemotePackagesAndSources();
 		const dir = path.dirname(
-			this.delve.remotePath.length
+			this.delve.remotePath.length || this.delve.isRemoteDebugging
 				? this.toLocalPath(debugState.currentThread.file)
 				: debugState.currentThread.file
 		);
@@ -1909,6 +2134,63 @@ class GoDebugSession extends LoggingDebugSession {
 	}
 }
 
+// Class for fetching remote sources and packages
+// in the remote program using Delve.
+// tslint:disable-next-line:max-classes-per-file
+class RemoteSourcesAndPackages extends EventEmitter {
+	public static readonly INITIALIZED = 'INITIALIZED';
+
+	public initializingRemoteSourceFiles = false;
+	public initializedRemoteSourceFiles = false;
+
+	public remotePackagesBuildInfo: PackageBuildInfo[] = [];
+	public remoteSourceFiles: string[] = [];
+	public remoteSourceFilesNameGrouping = new Map<string, string[]>();
+
+	/**
+	 * Initialize and fill out remote packages build info and remote source files.
+	 * Emits the INITIALIZED event once initialization is complete.
+	 */
+	public async initializeRemotePackagesAndSources(delve: Delve): Promise<void> {
+		this.initializingRemoteSourceFiles = true;
+
+		try {
+			// ListPackagesBuildInfo is not available on V1.
+			if (!delve.isApiV1 && this.remotePackagesBuildInfo.length === 0) {
+				const packagesBuildInfoResponse: ListPackagesBuildInfoOut = await delve.callPromise(
+					'ListPackagesBuildInfo', [{IncludeFiles: true}]
+				);
+				if (packagesBuildInfoResponse && packagesBuildInfoResponse.List) {
+					this.remotePackagesBuildInfo = packagesBuildInfoResponse.List;
+				}
+			}
+
+			// List sources will return all the source files used by Delve.
+			if (delve.isApiV1) {
+				this.remoteSourceFiles = await delve.callPromise('ListSources', []);
+			} else {
+				const listSourcesResponse: ListSourcesOut = await delve.callPromise('ListSources', [{}]);
+				if (listSourcesResponse && listSourcesResponse.Sources) {
+					this.remoteSourceFiles = listSourcesResponse.Sources;
+				}
+			}
+
+			// Group the source files by name for easy searching later.
+			this.remoteSourceFiles = this.remoteSourceFiles.filter((sourceFile) => !sourceFile.startsWith('<'));
+			this.remoteSourceFiles.forEach((sourceFile) => {
+				const fileName = getBaseName(sourceFile);
+				if (!this.remoteSourceFilesNameGrouping.has(fileName)) {
+					this.remoteSourceFilesNameGrouping.set(fileName, []);
+				}
+				this.remoteSourceFilesNameGrouping.get(fileName).push(sourceFile);
+			});
+		} finally {
+			this.emit(RemoteSourcesAndPackages.INITIALIZED);
+			this.initializedRemoteSourceFiles = true;
+		}
+	}
+}
+
 function random(low: number, high: number): number {
 	return Math.floor(Math.random() * (high - low) + low);
 }