[release] prepare v0.19.0 release, part 2

455e1a9 snippets: add snippet for TestMain
bf1225f src/goEnv: unset GOOS/GOARCH/GOROOT/... from tool installation env
d7563f6 src/goInstallTools: use GOROOT/bin for gocode-gomod build too
3493cfe src/goDebug: respect user cwd debug configuration in noDebug
ec9a5f8 src/goDebugConfiguration: remove user set '--gcflags' from config
3c7e4da package.json: add missing transform variants for go.addTags
c13bcfe src/testUtils: fix test streaming output handling
2c5a0b9 src/testUtils: hide running test StatusBarItem after cancelling tests
a4e523d src/testUtils: convert a goTest promise chain to async-await

Change-Id: I5bcbf26cf7119e02f23e72937e73dc647f392ddd

Author: suzmue

docs/debugging.md

@@ -9,6 +9,7 @@ This document explains how to debug your Go programs in VS Code. The Go debugger
   * [Configuration](#configuration)
 * [Launch Configurations](#launch-configurations)
   * [Specifying build tags](#specifying-build-tags)
+  * [Specifying other build flags](#specifying-other-build-flags)
   * [Using VS Code Variables](#using-vs-code-variables)
   * [Snippets](#snippets)
 * [Debugging on Windows Subsystem for Linux (WSL)](#debugging-on-windows-subsystem-for-linux-wsl)
@@ -135,6 +136,22 @@ in your launch configuration. This property supports multiple tags, which you ca
 
 <!--TODO(rstambler): Confirm that the extension works with a comma (not space) separated list.-->
 
+### Specifying other build flags
+
+The flags specified in `buildFlags` and `env.GOFLAGS` are passed to the Go compiler when building your program for debugging. Delve adds `--gcflags='all=-N -l'` to the list of build flags to disable optimizations. User specified buildFlags conflict with this setting, so the extension removes them ([Issue #117](https://github.com/golang/vscode-go/issues/117)). If you wish to debug a program using custom `--gcflags`, build the program using `go build` and launch using `exec` mode:
+
+```json
+{
+    "name": "Launch executable",
+    "type": "go",
+    "request": "launch",
+    "mode": "exec",
+    "program": "/absolute/path/to/executable"
+}
+```
+
+Note that it is not recommended to debug optimized executables as Delve may not have the information necessary to properly debug your program.
+
 ### Using [VS Code variables]
 
 Any property in the launch configuration that requires a file path can be specified in terms of [VS Code variables]. Here are some useful ones to know:

package-lock.json

@@ -46,6 +46,7 @@
   },
   "extensionDependencies": [],
   "dependencies": {
+    "@types/yargs-parser": "^15.0.0",
     "deep-equal": "^2.0.2",
     "diff": "^4.0.2",
     "glob": "^7.1.6",
@@ -1689,7 +1690,10 @@
               "type": "string",
               "enum": [
                 "snakecase",
-                "camelcase"
+                "camelcase",
+                "lispcase",
+                "pascalcase",
+                "keep"
               ],
               "default": "snakecase",
               "description": "Transformation rule used by Go: Add Tags command to add tags"

package.json

@@ -215,6 +215,11 @@
 			"body": "func Test$1(t *testing.T) {\n\t$0\n}",
 			"description": "Snippet for Test function"
 		},
+		"test main": {
+			"prefix": "tm",
+			"body": "func TestMain(m *testing.M) {\n\t$1\n\n\tos.Exit(m.Run())\n}",
+			"description": "Snippet for TestMain function"
+		},
 		"benchmark function": {
 			"prefix": "bf",
 			"body": "func Benchmark$1(b *testing.B) {\n\tfor ${2:i} := 0; ${2:i} < b.N; ${2:i}++ {\n\t\t$0\n\t}\n}",

snippets/go.json

@@ -3,7 +3,7 @@
  * Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------*/
 
-import { ChildProcess, execFile, spawn } from 'child_process';
+import { ChildProcess, execFile, spawn, spawnSync } from 'child_process';
 import { EventEmitter } from 'events';
 import * as fs from 'fs';
 import { existsSync, lstatSync } from 'fs';
@@ -481,25 +481,68 @@ export class Delve {
 				if (!!launchArgs.noDebug) {
 					if (mode === 'debug') {
 						this.noDebug = true;
-						const runArgs = ['run'];
-						const runOptions: { [key: string]: any } = { cwd: dirname, env };
+						const build = ['build'];
+
+						const output = path.join(os.tmpdir(), 'out');
+						build.push(`-o=${output}`);
+
+						const buildOptions: { [key: string]: any } = { cwd: dirname, env };
 						if (launchArgs.buildFlags) {
-							runArgs.push(launchArgs.buildFlags);
+							build.push(launchArgs.buildFlags);
 						}
+
 						if (isProgramDirectory) {
-							runArgs.push('.');
+							build.push('.');
 						} else {
-							runArgs.push(program);
-						}
-						if (launchArgs.args) {
-							runArgs.push(...launchArgs.args);
+							build.push(program);
 						}
 
 						const goExe = getBinPathWithPreferredGopathGoroot('go', []);
 						log(`Current working directory: ${dirname}`);
-						log(`Running: ${goExe} ${runArgs.join(' ')}`);
+						log(`Building: ${goExe} ${build.join(' ')}`);
+
+						// Use spawnSync to ensure that the binary exists before running it.
+						const buffer = spawnSync(goExe, build, buildOptions);
+						if (buffer.stderr  && buffer.stderr.length > 0) {
+							const str = buffer.stderr.toString();
+							if (this.onstderr) {
+								this.onstderr(str);
+							}
+						}
+						if (buffer.stdout && buffer.stdout.length > 0) {
+							const str = buffer.stdout.toString();
+							if (this.onstdout) {
+								this.onstdout(str);
+							}
+						}
+						if (buffer.status) {
+							logError(`Build process exiting with code: ${buffer.status} signal: ${buffer.signal}`);
+							if (this.onclose) {
+								this.onclose(buffer.status);
+							}
+						} else {
+							log(`Build process exiting normally ${buffer.signal}`);
+						}
+						if (buffer.error) {
+							reject(buffer.error);
+						}
 
-						this.debugProcess = spawn(goExe, runArgs, runOptions);
+						// Run the built binary
+						let wd = dirname;
+						if (!!launchArgs.cwd) {
+							wd = launchArgs.cwd;
+						}
+						const runOptions: { [key: string]: any } = { cwd: wd, env };
+
+						const run = [];
+						if (launchArgs.args) {
+							run.push(...launchArgs.args);
+						}
+
+						log(`Current working directory: ${wd}`);
+						log(`Running: ${output} ${run.join(' ')}`);
+
+						this.debugProcess = spawn(output, run, runOptions);
 						this.debugProcess.stderr.on('data', (chunk) => {
 							const str = chunk.toString();
 							if (this.onstderr) {
@@ -525,6 +568,7 @@ export class Delve {
 						this.debugProcess.on('error', (err) => {
 							reject(err);
 						});
+
 						resolve();
 						return;
 					}

src/debugAdapter/goDebug.ts

@@ -7,6 +7,8 @@
 
 import path = require('path');
 import vscode = require('vscode');
+import parse = require('yargs-parser');
+import unparse = require('yargs-unparser');
 import { toolExecutionEnvironment } from './goEnv';
 import { promptForMissingTool } from './goInstallTools';
 import { packagePathToGoModPathMap } from './goModules';
@@ -92,6 +94,28 @@ export class GoDebugConfigurationProvider implements vscode.DebugConfigurationPr
 			debugConfiguration['cwd'] = resolvePath(debugConfiguration['cwd']);
 		}
 
+		// Remove any '--gcflags' entries and show a warning
+		if (debugConfiguration['buildFlags']) {
+			const resp = this.removeFlag(debugConfiguration['buildFlags'], 'gcflags');
+			if (resp.removed) {
+				debugConfiguration['buildFlags'] = resp.args;
+				this.showWarning(
+					'ignoreDebugGCFlagsWarning',
+					`User specified build flag '--gcflags' in 'buildFlags' is being ignored (see [debugging with build flags](https://github.com/golang/vscode-go/blob/master/docs/debugging.md#specifying-other-build-flags) documentation)`
+				);
+			}
+		}
+		if (debugConfiguration['env'] && debugConfiguration['env']['GOFLAGS']) {
+			const resp = this.removeFlag(debugConfiguration['env']['GOFLAGS'], 'gcflags');
+			if (resp.removed) {
+				debugConfiguration['env']['GOFLAGS'] = resp.args;
+				this.showWarning(
+					'ignoreDebugGCFlagsWarning',
+					`User specified build flag '--gcflags' in 'GOFLAGS' is being ignored (see [debugging with build flags](https://github.com/golang/vscode-go/blob/master/docs/debugging.md#specifying-other-build-flags) documentation)`
+				);
+			}
+		}
+
 		debugConfiguration['dlvToolPath'] = getBinPath('dlv');
 		if (!path.isAbsolute(debugConfiguration['dlvToolPath'])) {
 			promptForMissingTool('dlv');
@@ -156,4 +180,13 @@ export class GoDebugConfigurationProvider implements vscode.DebugConfigurationPr
 			}
 		});
 	}
+
+	private removeFlag(args: string, flag: string): {args: string, removed: boolean} {
+		const argv = parse(args, {configuration: {'short-option-groups': false}});
+		if (argv[flag]) {
+			delete argv[flag];
+			return { args: unparse(argv).join(' '), removed: true };
+		}
+		return {args, removed: false};
+	}
 }

src/goDebugConfiguration.ts

@@ -39,6 +39,15 @@ export function toolInstallationEnvironment(): NodeJS.Dict<string> {
 	}
 	env['GOPATH'] = toolsGopath;
 
+	// Unset env vars that would affect tool build process: 'GOROOT', 'GOOS', 'GOARCH', ...
+	// Tool installation should be done for the host OS/ARCH (GOHOSTOS/GOHOSTARCH) with
+	// the default setup.
+	delete env['GOOS'];
+	delete env['GOARCH'];
+	delete env['GOROOT'];
+	delete env['GOFLAGS'];
+	delete env['GOENV'];
+
 	return env;
 }
 

src/goEnv.ts

@@ -242,15 +242,15 @@ export async function installTool(
 
 		// TODO(rstambler): Figure out why this happens and maybe delete it.
 		if (stderr.indexOf('unexpected directory layout:') > -1) {
-			await execFile(goVersion.binaryPath, args, opts);
+			await execFile(goBinary, args, opts);
 		} else if (hasModSuffix(tool)) {
 			const gopath = env['GOPATH'];
 			if (!gopath) {
 				return `GOPATH not configured in environment`;
 			}
 			const destDir = gopath.split(path.delimiter)[0];
 			const outputFile = path.join(destDir, 'bin', process.platform === 'win32' ? `${tool.name}.exe` : tool.name);
-			await execFile(goVersion.binaryPath, ['build', '-o', outputFile, importPath], opts);
+			await execFile(goBinary, ['build', '-o', outputFile, importPath], opts);
 		}
 		const toolInstallPath = getBinPath(tool.name);
 		outputChannel.appendLine(`Installing ${toolImportPath} (${toolInstallPath}) SUCCEEDED`);