blob: e29245f7ac1a2909a5cf5644a22b0df7a2d92a5b [file] [log] [blame]
/*---------------------------------------------------------
* Copyright (C) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See LICENSE in the project root for license information.
*--------------------------------------------------------*/
import cp = require('child_process');
import fs = require('fs');
import os = require('os');
import path = require('path');
import semver = require('semver');
import util = require('util');
import vscode = require('vscode');
import { NearestNeighborDict, Node } from './avlTree';
import { extensionId } from './const';
import { toolExecutionEnvironment } from './goEnv';
import { buildDiagnosticCollection, lintDiagnosticCollection, vetDiagnosticCollection } from './goMain';
import { getCurrentPackage } from './goModules';
import { outputChannel } from './goStatus';
import { getFromWorkspaceState } from './stateUtils';
import {
envPath,
fixDriveCasingInWindows,
getBinPathWithPreferredGopathGoroot,
getCurrentGoRoot,
getInferredGopath,
resolveHomeDir,
} from './utils/goPath';
import { killProcessTree } from './utils/processUtils';
let userNameHash: number = 0;
export const goKeywords: string[] = [
'break',
'case',
'chan',
'const',
'continue',
'default',
'defer',
'else',
'fallthrough',
'for',
'func',
'go',
'goto',
'if',
'import',
'interface',
'map',
'package',
'range',
'return',
'select',
'struct',
'switch',
'type',
'var'
];
export const goBuiltinTypes: Set<string> = new Set<string>([
'bool',
'byte',
'complex128',
'complex64',
'error',
'float32',
'float64',
'int',
'int16',
'int32',
'int64',
'int8',
'rune',
'string',
'uint',
'uint16',
'uint32',
'uint64',
'uint8',
'uintptr'
]);
export class GoVersion {
public sv?: semver.SemVer;
// Go version tags are not following the strict semver format
// so semver drops the prerelease tags used in Go version.
// If sv is valid, let's keep the original version string
// including the prerelease tag parts.
public svString?: string;
public isDevel?: boolean;
private commit?: string;
constructor(public binaryPath: string, public version: string) {
const matchesRelease = /^go version go(\d\.\d+\S*)\s+/.exec(version);
const matchesDevel = /go version devel \+(.[a-zA-Z0-9]+).*/.exec(version);
if (matchesRelease) {
// note: semver.parse does not work with Go version string like go1.14.
const sv = semver.coerce(matchesRelease[1]);
if (sv) {
this.sv = sv;
this.svString = matchesRelease[1];
}
} else if (matchesDevel) {
this.isDevel = true;
this.commit = matchesDevel[1];
}
}
public isValid(): boolean {
return !!this.sv || !!this.isDevel;
}
public format(includePrerelease?: boolean): string {
if (this.sv) {
if (includePrerelease && this.svString) {
return this.svString;
}
return this.sv.format();
}
if (this.isDevel) {
return `devel +${this.commit}`;
}
return `unknown`;
}
public lt(version: string): boolean {
// Assume a developer version is always above any released version.
// This is not necessarily true.
if (this.isDevel || !this.sv) {
return false;
}
const v = semver.coerce(version);
if (!v) {
return false;
}
return semver.lt(this.sv, v);
}
public gt(version: string): boolean {
// Assume a developer version is always above any released version.
// This is not necessarily true.
if (this.isDevel || !this.sv) {
return true;
}
const v = semver.coerce(version);
if (!v) {
return false;
}
return semver.gt(this.sv, v);
}
}
let cachedGoBinPath: string | undefined;
let cachedGoVersion: GoVersion | undefined;
let vendorSupport: boolean | undefined;
let toolsGopath: string;
// getGoConfig is declared as an exported const rather than a function, so it can be stubbbed in testing.
export const getGoConfig = (uri?: vscode.Uri) => {
if (!uri) {
if (vscode.window.activeTextEditor) {
uri = vscode.window.activeTextEditor.document.uri;
} else {
uri = null;
}
}
return vscode.workspace.getConfiguration('go', uri);
};
export function byteOffsetAt(document: vscode.TextDocument, position: vscode.Position): number {
const offset = document.offsetAt(position);
const text = document.getText();
return Buffer.byteLength(text.substr(0, offset));
}
export interface Prelude {
imports: Array<{ kind: string; start: number; end: number; pkgs: string[] }>;
pkg: { start: number; end: number; name: string };
}
export function parseFilePrelude(text: string): Prelude {
const lines = text.split('\n');
const ret: Prelude = { imports: [], pkg: null };
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
const pkgMatch = line.match(/^(\s)*package(\s)+(\w+)/);
if (pkgMatch) {
ret.pkg = { start: i, end: i, name: pkgMatch[3] };
}
if (line.match(/^(\s)*import(\s)+\(/)) {
ret.imports.push({ kind: 'multi', start: i, end: -1, pkgs: [] });
} else if (line.match(/^\s*import\s+"C"/)) {
ret.imports.push({ kind: 'pseudo', start: i, end: i, pkgs: [] });
} else if (line.match(/^(\s)*import(\s)+[^\(]/)) {
ret.imports.push({ kind: 'single', start: i, end: i, pkgs: [] });
}
if (line.match(/^(\s)*(\/\*.*\*\/)*\s*\)/)) { // /* comments */
if (ret.imports[ret.imports.length - 1].end === -1) {
ret.imports[ret.imports.length - 1].end = i;
}
} else if (ret.imports.length) {
if (ret.imports[ret.imports.length - 1].end === -1) {
const importPkgMatch = line.match(/"([^"]+)"/);
if (importPkgMatch) {
ret.imports[ret.imports.length - 1].pkgs.push(importPkgMatch[1]);
}
}
}
if (line.match(/^(\s)*(func|const|type|var)\s/)) {
break;
}
}
return ret;
}
// Takes a Go function signature like:
// (foo, bar string, baz number) (string, string)
// and returns an array of parameter strings:
// ["foo", "bar string", "baz string"]
// Takes care of balancing parens so to not get confused by signatures like:
// (pattern string, handler func(ResponseWriter, *Request)) {
export function getParametersAndReturnType(signature: string): { params: string[]; returnType: string } {
const params: string[] = [];
let parenCount = 0;
let lastStart = 1;
for (let i = 1; i < signature.length; i++) {
switch (signature[i]) {
case '(':
parenCount++;
break;
case ')':
parenCount--;
if (parenCount < 0) {
if (i > lastStart) {
params.push(signature.substring(lastStart, i));
}
return {
params,
returnType: i < signature.length - 1 ? signature.substr(i + 1) : ''
};
}
break;
case ',':
if (parenCount === 0) {
params.push(signature.substring(lastStart, i));
lastStart = i + 2;
}
break;
}
}
return { params: [], returnType: '' };
}
export function canonicalizeGOPATHPrefix(filename: string): string {
const gopath: string = getCurrentGoPath();
if (!gopath) {
return filename;
}
const workspaces = gopath.split(path.delimiter);
const filenameLowercase = filename.toLowerCase();
// In case of multiple workspaces, find current workspace by checking if current file is
// under any of the workspaces in $GOPATH
let currentWorkspace: string = null;
for (const workspace of workspaces) {
// In case of nested workspaces, (example: both /Users/me and /Users/me/a/b/c are in $GOPATH)
// both parent & child workspace in the nested workspaces pair can make it inside the above if block
// Therefore, the below check will take longer (more specific to current file) of the two
if (
filenameLowercase.substring(0, workspace.length) === workspace.toLowerCase() &&
(!currentWorkspace || workspace.length > currentWorkspace.length)
) {
currentWorkspace = workspace;
}
}
if (!currentWorkspace) {
return filename;
}
return currentWorkspace + filename.slice(currentWorkspace.length);
}
/**
* Gets a numeric hash based on given string.
* Returns a number between 0 and 4294967295.
*/
export function getStringHash(value: string): number {
let hash = 5381;
let i = value.length;
while (i) {
hash = (hash * 33) ^ value.charCodeAt(--i);
}
/* JavaScript does bitwise operations (like XOR, above) on 32-bit signed
* integers. Since we want the results to be always positive, convert the
* signed int to an unsigned by doing an unsigned bitshift. */
return hash >>> 0;
}
export function getUserNameHash() {
if (userNameHash) {
return userNameHash;
}
try {
userNameHash = getStringHash(os.userInfo().username);
} catch (error) {
userNameHash = 1;
}
return userNameHash;
}
/**
* Gets version of Go based on the output of the command `go version`.
* Returns undefined if go version can't be determined because
* go is not available or `go version` fails.
*/
export async function getGoVersion(): Promise<GoVersion | undefined> {
// TODO(hyangah): limit the number of concurrent getGoVersion call.
// When the extension starts, at least 4 concurrent calls race
// and end up calling `go version`.
const goRuntimePath = getBinPath('go');
const warn = (msg: string) => {
outputChannel.appendLine(msg);
console.warn(msg);
};
if (!goRuntimePath) {
warn(`unable to locate "go" binary in GOROOT (${getCurrentGoRoot()}) or PATH (${envPath})`);
return;
}
if (cachedGoBinPath === goRuntimePath && cachedGoVersion) {
if (cachedGoVersion.isValid()) {
return Promise.resolve(cachedGoVersion);
}
warn(`cached Go version (${JSON.stringify(cachedGoVersion)}) is invalid, recomputing`);
}
try {
const execFile = util.promisify(cp.execFile);
const { stdout, stderr } = await execFile(goRuntimePath, ['version']);
if (stderr) {
warn(`failed to run "${goRuntimePath} version": stdout: ${stdout}, stderr: ${stderr}`);
return;
}
cachedGoBinPath = goRuntimePath;
cachedGoVersion = new GoVersion(goRuntimePath, stdout);
} catch (err) {
warn(`failed to run "${goRuntimePath} version": ${err}`);
return;
}
return cachedGoVersion;
}
/**
* Returns the output of `go env` from the specified directory.
* Throws an error if the command fails.
*/
export async function getGoEnv(cwd?: string): Promise<string> {
const goRuntime = getBinPath('go');
const execFile = util.promisify(cp.execFile);
const opts = {cwd, env: toolExecutionEnvironment()};
const { stdout, stderr } = await execFile(goRuntime, ['env'], opts);
if (stderr) {
throw new Error(`failed to run 'go env': ${stderr}`);
}
return stdout;
}
/**
* Returns boolean denoting if current version of Go supports vendoring
*/
export async function isVendorSupported(): Promise<boolean> {
if (vendorSupport != null) {
return Promise.resolve(vendorSupport);
}
const goVersion = await getGoVersion();
if (!goVersion.sv) {
return process.env['GO15VENDOREXPERIMENT'] === '0' ? false : true;
}
switch (goVersion.sv.major) {
case 0:
vendorSupport = false;
break;
case 1:
vendorSupport =
goVersion.sv.minor > 6 ||
((goVersion.sv.minor === 5 || goVersion.sv.minor === 6) && process.env['GO15VENDOREXPERIMENT'] === '1')
? true
: false;
break;
default:
vendorSupport = true;
break;
}
return vendorSupport;
}
/**
* Returns boolean indicating if GOPATH is set or not
* If not set, then prompts user to do set GOPATH
*/
export function isGoPathSet(): boolean {
if (!getCurrentGoPath()) {
// TODO(hyangah): is it still possible after go1.8? (https://golang.org/doc/go1.8#gopath)
vscode.window
.showInformationMessage(
'Set GOPATH environment variable and restart VS Code or set GOPATH in Workspace settings',
'Set GOPATH in Workspace Settings'
)
.then((selected) => {
if (selected === 'Set GOPATH in Workspace Settings') {
vscode.commands.executeCommand('workbench.action.openWorkspaceSettings');
}
});
return false;
}
return true;
}
export function isPositionInString(document: vscode.TextDocument, position: vscode.Position): boolean {
const lineText = document.lineAt(position.line).text;
const lineTillCurrentPosition = lineText.substr(0, position.character);
// Count the number of double quotes in the line till current position. Ignore escaped double quotes
let doubleQuotesCnt = (lineTillCurrentPosition.match(/\"/g) || []).length;
const escapedDoubleQuotesCnt = (lineTillCurrentPosition.match(/\\\"/g) || []).length;
doubleQuotesCnt -= escapedDoubleQuotesCnt;
return doubleQuotesCnt % 2 === 1;
}
export function getToolsGopath(useCache: boolean = true): string {
if (!useCache || !toolsGopath) {
toolsGopath = resolveToolsGopath();
}
return toolsGopath;
}
function resolveToolsGopath(): string {
let toolsGopathForWorkspace = substituteEnv(getGoConfig()['toolsGopath'] || '');
// In case of single root
if (!vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length <= 1) {
return resolvePath(toolsGopathForWorkspace);
}
// In case of multi-root, resolve ~ and ${workspaceFolder}
if (toolsGopathForWorkspace.startsWith('~')) {
toolsGopathForWorkspace = path.join(os.homedir(), toolsGopathForWorkspace.substr(1));
}
if (
toolsGopathForWorkspace &&
toolsGopathForWorkspace.trim() &&
!/\${workspaceFolder}|\${workspaceRoot}/.test(toolsGopathForWorkspace)
) {
return toolsGopathForWorkspace;
}
// If any of the folders in multi root have toolsGopath set, use it.
for (const folder of vscode.workspace.workspaceFolders) {
let toolsGopathFromConfig = <string>getGoConfig(folder.uri).inspect('toolsGopath').workspaceFolderValue;
toolsGopathFromConfig = resolvePath(toolsGopathFromConfig, folder.uri.fsPath);
if (toolsGopathFromConfig) {
return toolsGopathFromConfig;
}
}
}
export function getBinPath(tool: string, useCache = true): string {
const cfg = getGoConfig();
const alternateTools: { [key: string]: string } = cfg.get('alternateTools');
const alternateToolPath: string = alternateTools[tool];
let selectedGoPath: string | undefined;
if (tool === 'go') {
selectedGoPath = getFromWorkspaceState('selectedGo')?.binpath;
}
return getBinPathWithPreferredGopathGoroot(
tool,
tool === 'go' ? [] : [getToolsGopath(), getCurrentGoPath()],
tool === 'go' && cfg.get('goroot') ? cfg.get('goroot') : undefined,
selectedGoPath ?? resolvePath(alternateToolPath),
useCache
);
}
export function getFileArchive(document: vscode.TextDocument): string {
const fileContents = document.getText();
return document.fileName + '\n' + Buffer.byteLength(fileContents, 'utf8') + '\n' + fileContents;
}
export function substituteEnv(input: string): string {
return input.replace(/\${env:([^}]+)}/g, (match, capture) => {
return process.env[capture.trim()] || '';
});
}
let currentGopath = '';
export function getCurrentGoPath(workspaceUri?: vscode.Uri): string {
const activeEditorUri = vscode.window.activeTextEditor && vscode.window.activeTextEditor.document.uri;
const currentFilePath = fixDriveCasingInWindows(activeEditorUri && activeEditorUri.fsPath);
const currentRoot = (workspaceUri && workspaceUri.fsPath) || getWorkspaceFolderPath(activeEditorUri);
const config = getGoConfig(workspaceUri || activeEditorUri);
// Infer the GOPATH from the current root or the path of the file opened in current editor
// Last resort: Check for the common case where GOPATH itself is opened directly in VS Code
let inferredGopath: string;
if (config['inferGopath'] === true) {
inferredGopath = getInferredGopath(currentRoot) || getInferredGopath(currentFilePath);
if (!inferredGopath) {
try {
if (fs.statSync(path.join(currentRoot, 'src')).isDirectory()) {
inferredGopath = currentRoot;
}
} catch (e) {
// No op
}
}
if (inferredGopath && process.env['GOPATH'] && inferredGopath !== process.env['GOPATH']) {
inferredGopath += path.delimiter + process.env['GOPATH'];
}
}
const configGopath = config['gopath'] ? resolvePath(substituteEnv(config['gopath']), currentRoot) : '';
currentGopath = inferredGopath ? inferredGopath : configGopath || process.env['GOPATH'];
return currentGopath;
}
export function getModuleCache(): string {
if (process.env['GOMODCACHE']) {
return process.env['GOMODCACHE'];
}
if (currentGopath) {
return path.join(currentGopath.split(path.delimiter)[0], 'pkg', 'mod');
}
}
export function getExtensionCommands(): any[] {
const pkgJSON = vscode.extensions.getExtension(extensionId).packageJSON;
if (!pkgJSON.contributes || !pkgJSON.contributes.commands) {
return;
}
const extensionCommands: any[] = vscode.extensions
.getExtension(extensionId)
.packageJSON.contributes.commands.filter((x: any) => x.command !== 'go.show.commands');
return extensionCommands;
}
export class LineBuffer {
private buf: string = '';
private lineListeners: { (line: string): void }[] = [];
private lastListeners: { (last: string): void }[] = [];
public append(chunk: string) {
this.buf += chunk;
do {
const idx = this.buf.indexOf('\n');
if (idx === -1) {
break;
}
this.fireLine(this.buf.substring(0, idx));
this.buf = this.buf.substring(idx + 1);
} while (true);
}
public done() {
this.fireDone(this.buf !== '' ? this.buf : null);
}
public onLine(listener: (line: string) => void) {
this.lineListeners.push(listener);
}
public onDone(listener: (last: string) => void) {
this.lastListeners.push(listener);
}
private fireLine(line: string) {
this.lineListeners.forEach((listener) => listener(line));
}
private fireDone(last: string) {
this.lastListeners.forEach((listener) => listener(last));
}
}
export function timeout(millis: number): Promise<void> {
return new Promise<void>((resolve, reject) => {
setTimeout(() => resolve(), millis);
});
}
/**
* Expands ~ to homedir in non-Windows platform and resolves ${workspaceFolder} or ${workspaceRoot}
*/
export function resolvePath(inputPath: string, workspaceFolder?: string): string {
if (!inputPath || !inputPath.trim()) {
return inputPath;
}
if (!workspaceFolder && vscode.workspace.workspaceFolders) {
workspaceFolder = getWorkspaceFolderPath(
vscode.window.activeTextEditor && vscode.window.activeTextEditor.document.uri
);
}
if (workspaceFolder) {
inputPath = inputPath.replace(/\${workspaceFolder}|\${workspaceRoot}/g, workspaceFolder);
}
return resolveHomeDir(inputPath);
}
/**
* Returns the import path in a passed in string.
* @param text The string to search for an import path
*/
export function getImportPath(text: string): string {
// Catch cases like `import alias "importpath"` and `import "importpath"`
const singleLineImportMatches = text.match(/^\s*import\s+([a-z,A-Z,_,\.]\w*\s+)?\"([^\"]+)\"/);
if (singleLineImportMatches) {
return singleLineImportMatches[2];
}
// Catch cases like `alias "importpath"` and "importpath"
const groupImportMatches = text.match(/^\s*([a-z,A-Z,_,\.]\w*\s+)?\"([^\"]+)\"/);
if (groupImportMatches) {
return groupImportMatches[2];
}
return '';
}
// TODO: Add unit tests for the below
/**
* Guess the package name based on parent directory name of the given file
*
* Cases:
* - dir 'go-i18n' -> 'i18n'
* - dir 'go-spew' -> 'spew'
* - dir 'kingpin' -> 'kingpin'
* - dir 'go-expand-tilde' -> 'tilde'
* - dir 'gax-go' -> 'gax'
* - dir 'go-difflib' -> 'difflib'
* - dir 'jwt-go' -> 'jwt'
* - dir 'go-radix' -> 'radix'
*
* @param {string} filePath.
*/
export function guessPackageNameFromFile(filePath: string): Promise<string[]> {
return new Promise((resolve, reject) => {
const goFilename = path.basename(filePath);
if (goFilename === 'main.go') {
return resolve(['main']);
}
const directoryPath = path.dirname(filePath);
const dirName = path.basename(directoryPath);
let segments = dirName.split(/[\.-]/);
segments = segments.filter((val) => val !== 'go');
if (segments.length === 0 || !/[a-zA-Z_]\w*/.test(segments[segments.length - 1])) {
return reject();
}
const proposedPkgName = segments[segments.length - 1];
fs.stat(path.join(directoryPath, 'main.go'), (err, stats) => {
if (stats && stats.isFile()) {
return resolve(['main']);
}
if (goFilename.endsWith('_test.go')) {
return resolve([proposedPkgName, proposedPkgName + '_test']);
}
return resolve([proposedPkgName]);
});
});
}
export interface ICheckResult {
file: string;
line: number;
col: number;
msg: string;
severity: string;
}
/**
* Runs given Go tool and returns errors/warnings that can be fed to the Problems Matcher
* @param args Arguments to be passed while running given tool
* @param cwd cwd that will passed in the env object while running given tool
* @param severity error or warning
* @param useStdErr If true, the stderr of the output of the given tool will be used, else stdout will be used
* @param toolName The name of the Go tool to run. If none is provided, the go runtime itself is used
* @param printUnexpectedOutput If true, then output that doesnt match expected format is printed to the output channel
*/
export function runTool(
args: string[],
cwd: string,
severity: string,
useStdErr: boolean,
toolName: string,
env: any,
printUnexpectedOutput: boolean,
token?: vscode.CancellationToken
): Promise<ICheckResult[]> {
let cmd: string;
if (toolName) {
cmd = getBinPath(toolName);
} else {
const goRuntimePath = getBinPath('go');
if (!goRuntimePath) {
return Promise.reject(new Error('Cannot find "go" binary. Update PATH or GOROOT appropriately'));
}
cmd = goRuntimePath;
}
let p: cp.ChildProcess;
if (token) {
token.onCancellationRequested(() => {
if (p) {
killProcessTree(p);
}
});
}
cwd = fixDriveCasingInWindows(cwd);
return new Promise((resolve, reject) => {
p = cp.execFile(cmd, args, { env, cwd }, (err, stdout, stderr) => {
try {
if (err && (<any>err).code === 'ENOENT') {
// Since the tool is run on save which can be frequent
// we avoid sending explicit notification if tool is missing
console.log(`Cannot find ${toolName ? toolName : 'go'}`);
return resolve([]);
}
if (err && stderr && !useStdErr) {
outputChannel.appendLine(['Error while running tool:', cmd, ...args].join(' '));
outputChannel.appendLine(stderr);
return resolve([]);
}
const lines = (useStdErr ? stderr : stdout).toString().split('\n');
outputChannel.appendLine([cwd + '>Finished running tool:', cmd, ...args].join(' '));
const ret: ICheckResult[] = [];
let unexpectedOutput = false;
let atLeastSingleMatch = false;
for (const l of lines) {
if (l[0] === '\t' && ret.length > 0) {
ret[ret.length - 1].msg += '\n' + l;
continue;
}
const match = /^([^:]*: )?((.:)?[^:]*):(\d+)(:(\d+)?)?:(?:\w+:)? (.*)$/.exec(l);
if (!match) {
if (printUnexpectedOutput && useStdErr && stderr) {
unexpectedOutput = true;
}
continue;
}
atLeastSingleMatch = true;
const [, , file, , lineStr, , colStr, msg] = match;
const line = +lineStr;
const col = +colStr;
// Building skips vendor folders,
// But vet and lint take in directories and not import paths, so no way to skip them
// So prune out the results from vendor folders here.
if (
!path.isAbsolute(file) &&
(file.startsWith(`vendor${path.sep}`) || file.indexOf(`${path.sep}vendor${path.sep}`) > -1)
) {
continue;
}
const filePath = path.resolve(cwd, file);
ret.push({ file: filePath, line, col, msg, severity });
outputChannel.appendLine(`${filePath}:${line}: ${msg}`);
}
if (!atLeastSingleMatch && unexpectedOutput && vscode.window.activeTextEditor) {
outputChannel.appendLine(stderr);
if (err) {
ret.push({
file: vscode.window.activeTextEditor.document.fileName,
line: 1,
col: 1,
msg: stderr,
severity: 'error'
});
}
}
outputChannel.appendLine('');
resolve(ret);
} catch (e) {
reject(e);
}
});
});
}
export function handleDiagnosticErrors(
document: vscode.TextDocument,
errors: ICheckResult[],
diagnosticCollection: vscode.DiagnosticCollection
) {
diagnosticCollection.clear();
const diagnosticMap: Map<string, vscode.Diagnostic[]> = new Map();
errors.forEach((error) => {
const canonicalFile = vscode.Uri.file(error.file).toString();
let startColumn = 0;
let endColumn = 1;
if (document && document.uri.toString() === canonicalFile) {
const tempRange = new vscode.Range(
error.line - 1,
0,
error.line - 1,
document.lineAt(error.line - 1).range.end.character + 1
);
const text = document.getText(tempRange);
const [_, leading, trailing] = /^(\s*).*(\s*)$/.exec(text);
if (!error.col) {
startColumn = leading.length;
} else {
startColumn = error.col - 1; // range is 0-indexed
}
endColumn = text.length - trailing.length;
}
const range = new vscode.Range(error.line - 1, startColumn, error.line - 1, endColumn);
const severity = mapSeverityToVSCodeSeverity(error.severity);
const diagnostic = new vscode.Diagnostic(range, error.msg, severity);
diagnostic.source = diagnosticCollection.name;
let diagnostics = diagnosticMap.get(canonicalFile);
if (!diagnostics) {
diagnostics = [];
}
diagnostics.push(diagnostic);
diagnosticMap.set(canonicalFile, diagnostics);
});
diagnosticMap.forEach((newDiagnostics, file) => {
const fileUri = vscode.Uri.parse(file);
if (diagnosticCollection === buildDiagnosticCollection) {
// If there are lint/vet warnings on current file, remove the ones co-inciding with the new build errors
if (lintDiagnosticCollection.has(fileUri)) {
lintDiagnosticCollection.set(
fileUri,
deDupeDiagnostics(newDiagnostics, lintDiagnosticCollection.get(fileUri).slice())
);
}
if (vetDiagnosticCollection.has(fileUri)) {
vetDiagnosticCollection.set(
fileUri,
deDupeDiagnostics(newDiagnostics, vetDiagnosticCollection.get(fileUri).slice())
);
}
} else if (buildDiagnosticCollection.has(fileUri)) {
// If there are build errors on current file, ignore the new lint/vet warnings co-inciding with them
newDiagnostics = deDupeDiagnostics(buildDiagnosticCollection.get(fileUri).slice(), newDiagnostics);
}
diagnosticCollection.set(fileUri, newDiagnostics);
});
}
function deDupeDiagnostics(
buildDiagnostics: vscode.Diagnostic[],
otherDiagnostics: vscode.Diagnostic[]
): vscode.Diagnostic[] {
const buildDiagnosticsLines = buildDiagnostics.map((x) => x.range.start.line);
return otherDiagnostics.filter((x) => buildDiagnosticsLines.indexOf(x.range.start.line) === -1);
}
function mapSeverityToVSCodeSeverity(sev: string): vscode.DiagnosticSeverity {
switch (sev) {
case 'error':
return vscode.DiagnosticSeverity.Error;
case 'warning':
return vscode.DiagnosticSeverity.Warning;
default:
return vscode.DiagnosticSeverity.Error;
}
}
export function getWorkspaceFolderPath(fileUri?: vscode.Uri): string {
if (fileUri) {
const workspace = vscode.workspace.getWorkspaceFolder(fileUri);
if (workspace) {
return fixDriveCasingInWindows(workspace.uri.fsPath);
}
}
// fall back to the first workspace
const folders = vscode.workspace.workspaceFolders;
if (folders && folders.length) {
return fixDriveCasingInWindows(folders[0].uri.fsPath);
}
}
export function makeMemoizedByteOffsetConverter(buffer: Buffer): (byteOffset: number) => number {
const defaultValue = new Node<number, number>(0, 0); // 0 bytes will always be 0 characters
const memo = new NearestNeighborDict(defaultValue, NearestNeighborDict.NUMERIC_DISTANCE_FUNCTION);
return (byteOffset: number) => {
const nearest = memo.getNearest(byteOffset);
const byteDelta = byteOffset - nearest.key;
if (byteDelta === 0) {
return nearest.value;
}
let charDelta: number;
if (byteDelta > 0) {
charDelta = buffer.toString('utf8', nearest.key, byteOffset).length;
} else {
charDelta = -buffer.toString('utf8', byteOffset, nearest.key).length;
}
memo.insert(byteOffset, nearest.value + charDelta);
return nearest.value + charDelta;
};
}
export function rmdirRecursive(dir: string) {
if (fs.existsSync(dir)) {
fs.readdirSync(dir).forEach((file) => {
const relPath = path.join(dir, file);
if (fs.lstatSync(relPath).isDirectory()) {
rmdirRecursive(relPath);
} else {
try {
fs.unlinkSync(relPath);
} catch (err) {
console.log(`failed to remove ${relPath}: ${err}`);
}
}
});
fs.rmdirSync(dir);
}
}
let tmpDir: string;
/**
* Returns file path for given name in temp dir
* @param name Name of the file
*/
export function getTempFilePath(name: string): string {
if (!tmpDir) {
tmpDir = fs.mkdtempSync(os.tmpdir() + path.sep + 'vscode-go');
}
if (!fs.existsSync(tmpDir)) {
fs.mkdirSync(tmpDir);
}
return path.normalize(path.join(tmpDir, name));
}
export function cleanupTempDir() {
if (tmpDir) {
rmdirRecursive(tmpDir);
}
tmpDir = undefined;
}
/**
* Runs `go doc` to get documentation for given symbol
* @param cwd The cwd where the go doc process will be run
* @param packagePath Either the absolute path or import path of the package.
* @param symbol Symbol for which docs need to be found
* @param token Cancellation token
*/
export function runGodoc(
cwd: string,
packagePath: string,
receiver: string,
symbol: string,
token: vscode.CancellationToken
) {
if (!packagePath) {
return Promise.reject(new Error('Package Path not provided'));
}
if (!symbol) {
return Promise.reject(new Error('Symbol not provided'));
}
const goRuntimePath = getBinPath('go');
if (!goRuntimePath) {
return Promise.reject(new Error('Cannot find "go" binary. Update PATH or GOROOT appropriately'));
}
const getCurrentPackagePromise = path.isAbsolute(packagePath)
? getCurrentPackage(packagePath)
: Promise.resolve(packagePath);
return getCurrentPackagePromise.then((packageImportPath) => {
return new Promise<string>((resolve, reject) => {
if (receiver) {
receiver = receiver.replace(/^\*/, '');
symbol = receiver + '.' + symbol;
}
const env = toolExecutionEnvironment();
const args = ['doc', '-c', '-cmd', '-u', packageImportPath, symbol];
const p = cp.execFile(goRuntimePath, args, { env, cwd }, (err, stdout, stderr) => {
if (err) {
return reject(err.message || stderr);
}
let doc = '';
const godocLines = stdout.split('\n');
if (!godocLines.length) {
return resolve(doc);
}
// Recent versions of Go have started to include the package statement
// tht we dont need.
if (godocLines[0].startsWith('package ')) {
godocLines.splice(0, 1);
if (!godocLines[0].trim()) {
godocLines.splice(0, 1);
}
}
// Skip trailing empty lines
let lastLine = godocLines.length - 1;
for (; lastLine > 1; lastLine--) {
if (godocLines[lastLine].trim()) {
break;
}
}
for (let i = 1; i <= lastLine; i++) {
if (godocLines[i].startsWith(' ')) {
doc += godocLines[i].substring(4) + '\n';
} else if (!godocLines[i].trim()) {
doc += '\n';
}
}
return resolve(doc);
});
if (token) {
token.onCancellationRequested(() => {
killProcessTree(p);
});
}
});
});
}
/**
* Returns a boolean whether the current position lies within a comment or not
* @param document
* @param position
*/
export function isPositionInComment(document: vscode.TextDocument, position: vscode.Position): boolean {
const lineText = document.lineAt(position.line).text;
const commentIndex = lineText.indexOf('//');
if (commentIndex >= 0 && position.character > commentIndex) {
const commentPosition = new vscode.Position(position.line, commentIndex);
const isCommentInString = isPositionInString(document, commentPosition);
return !isCommentInString;
}
return false;
}