blob: 05e44bc6c36b4843a8524f9636644b1901d859a2 [file] [log] [blame]
/*---------------------------------------------------------
* Copyright (C) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See LICENSE in the project root for license information.
*--------------------------------------------------------*/
'use strict';
import cp = require('child_process');
import path = require('path');
import vscode = require('vscode');
import { toolExecutionEnvironment } from './goEnv';
import { promptForMissingTool } from './goInstallTools';
import {
byteOffsetAt,
canonicalizeGOPATHPrefix,
getBinPath,
getGoConfig,
getWorkspaceFolderPath
} from './util';
import { envPath, getCurrentGoRoot } from './utils/goPath';
import {killProcessTree} from './utils/processUtils';
interface GoListOutput {
Dir: string;
ImportPath: string;
Root: string;
}
interface GuruImplementsRef {
name: string;
pos: string;
kind: string;
}
interface GuruImplementsOutput {
type: GuruImplementsRef;
to: GuruImplementsRef[];
to_method: GuruImplementsRef[];
from: GuruImplementsRef[];
fromptr: GuruImplementsRef[];
}
export class GoImplementationProvider implements vscode.ImplementationProvider {
public provideImplementation(
document: vscode.TextDocument,
position: vscode.Position,
token: vscode.CancellationToken
): Thenable<vscode.Definition> {
// To keep `guru implements` fast we want to restrict the scope of the search to current workspace
// If no workspace is open, then no-op
const root = getWorkspaceFolderPath(document.uri);
if (!root) {
vscode.window.showInformationMessage('Cannot find implementations when there is no workspace open.');
return;
}
const goRuntimePath = getBinPath('go');
if (!goRuntimePath) {
vscode.window.showErrorMessage(
`Failed to run "go list" to get the scope to find implementations as the "go" binary cannot be found in either GOROOT(${getCurrentGoRoot()}) or PATH(${envPath})`
);
return;
}
return new Promise<vscode.Definition>((resolve, reject) => {
if (token.isCancellationRequested) {
return resolve(null);
}
const env = toolExecutionEnvironment();
const listProcess = cp.execFile(
goRuntimePath,
['list', '-e', '-json'],
{ cwd: root, env },
(err, stdout, stderr) => {
if (err) {
return reject(err);
}
const listOutput = <GoListOutput>JSON.parse(stdout.toString());
const filename = canonicalizeGOPATHPrefix(document.fileName);
const cwd = path.dirname(filename);
const offset = byteOffsetAt(document, position);
const goGuru = getBinPath('guru');
const buildTags = getGoConfig(document.uri)['buildTags'];
const args = buildTags ? ['-tags', buildTags] : [];
if (listOutput.Root && listOutput.ImportPath) {
args.push('-scope', `${listOutput.ImportPath}/...`);
}
args.push('-json', 'implements', `${filename}:#${offset.toString()}`);
const guruProcess = cp.execFile(goGuru, args, { env }, (guruErr, guruStdOut, guruStdErr) => {
if (guruErr && (<any>guruErr).code === 'ENOENT') {
promptForMissingTool('guru');
return resolve(null);
}
if (guruErr) {
return reject(guruErr);
}
const guruOutput = <GuruImplementsOutput>JSON.parse(guruStdOut.toString());
const results: vscode.Location[] = [];
const addResults = (list: GuruImplementsRef[]) => {
list.forEach((ref: GuruImplementsRef) => {
const match = /^(.*):(\d+):(\d+)/.exec(ref.pos);
if (!match) {
return;
}
const [_, file, lineStartStr, colStartStr] = match;
const referenceResource = vscode.Uri.file(path.resolve(cwd, file));
const range = new vscode.Range(
+lineStartStr - 1,
+colStartStr - 1,
+lineStartStr - 1,
+colStartStr
);
results.push(new vscode.Location(referenceResource, range));
});
};
// If we looked for implementation of method go to method implementations only
if (guruOutput.to_method) {
addResults(guruOutput.to_method);
} else if (guruOutput.to) {
addResults(guruOutput.to);
} else if (guruOutput.from) {
addResults(guruOutput.from);
} else if (guruOutput.fromptr) {
addResults(guruOutput.fromptr);
}
return resolve(results);
});
token.onCancellationRequested(() => killProcessTree(guruProcess));
}
);
token.onCancellationRequested(() => killProcessTree(listProcess));
});
}
}