Initial VS Code 1.19 source merge (#571)

* Initial 1.19 xcopy

* Fix yarn build

* Fix numerous build breaks

* Next batch of build break fixes

* More build break fixes

* Runtime breaks

* Additional post merge fixes

* Fix windows setup file

* Fix test failures.

* Update license header blocks to refer to source eula

src/vs/code/node/cli.ts

@@ -3,18 +3,21 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { spawn } from 'child_process';
+import { spawn, ChildProcess } from 'child_process';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { assign } from 'vs/base/common/objects';
 import { parseCLIProcessArgv, buildHelpMessage } from 'vs/platform/environment/node/argv';
 import { ParsedArgs } from 'vs/platform/environment/common/environment';
 import product from 'vs/platform/node/product';
 import pkg from 'vs/platform/node/package';
-
-import * as fs from 'fs';
 import * as paths from 'path';
 import * as os from 'os';
+import * as fs from 'fs';
 import { whenDeleted } from 'vs/base/node/pfs';
+import { findFreePort } from 'vs/base/node/ports';
+import { resolveTerminalEncoding } from 'vs/base/node/encoding';
+import * as iconv from 'iconv-lite';
+import { isWindows } from 'vs/base/common/platform';
 
 function shouldSpawnCliProcess(argv: ParsedArgs): boolean {
 	return !!argv['install-source']
@@ -27,7 +30,7 @@ interface IMainCli {
 	main: (argv: ParsedArgs) => TPromise<void>;
 }
 
-export function main(argv: string[]): TPromise<void> {
+export async function main(argv: string[]): TPromise<any> {
 	let args: ParsedArgs;
 
 	try {
@@ -37,24 +40,127 @@ export function main(argv: string[]): TPromise<void> {
 		return TPromise.as(null);
 	}
 
+	// Help
 	if (args.help) {
 		console.log(buildHelpMessage(product.nameLong, product.applicationName, pkg.version));
-	} else if (args.version) {
-		console.log(`${pkg.version}\n${product.commit}`);
-	} else if (shouldSpawnCliProcess(args)) {
+	}
+
+	// Version Info
+	else if (args.version) {
+		console.log(`${pkg.version}\n${product.commit}\n${process.arch}`);
+	}
+
+	// Extensions Management
+	else if (shouldSpawnCliProcess(args)) {
 		const mainCli = new TPromise<IMainCli>(c => require(['vs/code/node/cliProcessMain'], c));
 		return mainCli.then(cli => cli.main(args));
-	} else {
+	}
+
+	// Just Code
+	else {
 		const env = assign({}, process.env, {
-			// this will signal Code that it was spawned from this module
-			'VSCODE_CLI': '1',
+			'VSCODE_CLI': '1', // this will signal Code that it was spawned from this module
 			'ELECTRON_NO_ATTACH_CONSOLE': '1'
 		});
 
 		delete env['ELECTRON_RUN_AS_NODE'];
 
-		if (args.verbose) {
+		const processCallbacks: ((child: ChildProcess) => Thenable<any>)[] = [];
+
+		const verbose = args.verbose || args.status;
+		if (verbose) {
 			env['ELECTRON_ENABLE_LOGGING'] = '1';
+
+			processCallbacks.push(child => {
+				child.stdout.on('data', (data: Buffer) => console.log(data.toString('utf8').trim()));
+				child.stderr.on('data', (data: Buffer) => console.log(data.toString('utf8').trim()));
+
+				return new TPromise<void>(c => child.once('exit', () => c(null)));
+			});
+		}
+
+		let stdinWithoutTty: boolean;
+		try {
+			stdinWithoutTty = !process.stdin.isTTY; // Via https://twitter.com/MylesBorins/status/782009479382626304
+		} catch (error) {
+			// Windows workaround for https://github.com/nodejs/node/issues/11656
+		}
+
+		let stdinFilePath: string;
+		if (stdinWithoutTty) {
+
+			// Read from stdin: we require a single "-" argument to be passed in order to start reading from
+			// stdin. We do this because there is no reliable way to find out if data is piped to stdin. Just
+			// checking for stdin being connected to a TTY is not enough (https://github.com/Microsoft/vscode/issues/40351)
+			if (args._.length === 1 && args._[0] === '-') {
+
+				// remove the "-" argument when we read from stdin
+				args._ = [];
+				argv = argv.filter(a => a !== '-');
+
+				// prepare temp file to read stdin to
+				stdinFilePath = paths.join(os.tmpdir(), `code-stdin-${Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 3)}.txt`);
+
+				// open tmp file for writing
+				let stdinFileError: Error;
+				let stdinFileStream: fs.WriteStream;
+				try {
+					stdinFileStream = fs.createWriteStream(stdinFilePath);
+				} catch (error) {
+					stdinFileError = error;
+				}
+
+				if (!stdinFileError) {
+
+					// Pipe into tmp file using terminals encoding
+					resolveTerminalEncoding(verbose).done(encoding => {
+						const converterStream = iconv.decodeStream(encoding);
+						process.stdin.pipe(converterStream).pipe(stdinFileStream);
+					});
+
+					// Make sure to open tmp file
+					argv.push(stdinFilePath);
+
+					// Enable --wait to get all data and ignore adding this to history
+					argv.push('--wait');
+					argv.push('--skip-add-to-recently-opened');
+					args.wait = true;
+				}
+
+				if (verbose) {
+					if (stdinFileError) {
+						console.error(`Failed to create file to read via stdin: ${stdinFileError.toString()}`);
+					} else {
+						console.log(`Reading from stdin via: ${stdinFilePath}`);
+					}
+				}
+			}
+
+			// If the user pipes data via stdin but forgot to add the "-" argument, help by printing a message
+			// if we detect that data flows into via stdin after a certain timeout.
+			else if (args._.length === 0) {
+				processCallbacks.push(child => new TPromise(c => {
+					const dataListener = () => {
+						if (isWindows) {
+							console.log(`Run with '${product.applicationName} -' to read output from another program (e.g. 'echo Hello World | ${product.applicationName} -').`);
+						} else {
+							console.log(`Run with '${product.applicationName} -' to read from stdin (e.g. 'ps aux | grep code | ${product.applicationName} -').`);
+						}
+
+						c(void 0);
+					};
+
+					// wait for 1s maximum...
+					setTimeout(() => {
+						process.stdin.removeListener('data', dataListener);
+
+						c(void 0);
+					}, 1000);
+
+					// ...but finish early if we detect data
+					process.stdin.once('data', dataListener);
+				}));
+			}
 		}
 
 		// If we are started with --wait create a random temporary file
@@ -73,7 +179,7 @@ export function main(argv: string[]): TPromise<void> {
 				waitMarkerError = error;
 			}
 
-			if (args.verbose) {
+			if (verbose) {
 				if (waitMarkerError) {
 					console.error(`Failed to create marker file for --wait: ${waitMarkerError.toString()}`);
 				} else {
@@ -82,26 +188,76 @@ export function main(argv: string[]): TPromise<void> {
 			}
 		}
 
+		// If we have been started with `--prof-startup` we need to find free ports to profile
+		// the main process, the renderer, and the extension host. We also disable v8 cached data
+		// to get better profile traces. Last, we listen on stdout for a signal that tells us to
+		// stop profiling.
+		if (args['prof-startup']) {
+			const portMain = await findFreePort(9222, 10, 6000);
+			const portRenderer = await findFreePort(portMain + 1, 10, 6000);
+			const portExthost = await findFreePort(portRenderer + 1, 10, 6000);
+
+			if (!portMain || !portRenderer || !portExthost) {
+				console.error('Failed to find free ports for profiler to connect to do.');
+				return;
+			}
+
+			const filenamePrefix = paths.join(os.homedir(), Math.random().toString(16).slice(-4));
+
+			argv.push(`--inspect-brk=${portMain}`);
+			argv.push(`--remote-debugging-port=${portRenderer}`);
+			argv.push(`--inspect-brk-extensions=${portExthost}`);
+			argv.push(`--prof-startup-prefix`, filenamePrefix);
+			argv.push(`--no-cached-data`);
+
+			fs.writeFileSync(filenamePrefix, argv.slice(-6).join('|'));
+
+			processCallbacks.push(async child => {
+
+				// load and start profiler
+				const profiler = await import('v8-inspect-profiler');
+				const main = await profiler.startProfiling({ port: portMain });
+				const renderer = await profiler.startProfiling({ port: portRenderer, tries: 200 });
+				const extHost = await profiler.startProfiling({ port: portExthost, tries: 300 });
+
+				// wait for the renderer to delete the
+				// marker file
+				whenDeleted(filenamePrefix);
+
+				let profileMain = await main.stop();
+				let profileRenderer = await renderer.stop();
+				let profileExtHost = await extHost.stop();
+				let suffix = '';
+
+				if (!process.env['VSCODE_DEV']) {
+					// when running from a not-development-build we remove
+					// absolute filenames because we don't want to reveal anything
+					// about users. We also append the `.txt` suffix to make it
+					// easier to attach these files to GH issues
+					profileMain = profiler.rewriteAbsolutePaths(profileMain, 'piiRemoved');
+					profileRenderer = profiler.rewriteAbsolutePaths(profileRenderer, 'piiRemoved');
+					profileExtHost = profiler.rewriteAbsolutePaths(profileExtHost, 'piiRemoved');
+					suffix = '.txt';
+				}
+
+				// finally stop profiling and save profiles to disk
+				await profiler.writeProfile(profileMain, `${filenamePrefix}-main.cpuprofile${suffix}`);
+				await profiler.writeProfile(profileRenderer, `${filenamePrefix}-renderer.cpuprofile${suffix}`);
+				await profiler.writeProfile(profileExtHost, `${filenamePrefix}-exthost.cpuprofile${suffix}`);
+			});
+		}
+
 		const options = {
 			detached: true,
 			env
 		};
 
-		if (!args.verbose) {
+		if (!verbose) {
 			options['stdio'] = 'ignore';
 		}
 
 		const child = spawn(process.execPath, argv.slice(2), options);
 
-		if (args.verbose) {
-			child.stdout.on('data', (data: Buffer) => console.log(data.toString('utf8').trim()));
-			child.stderr.on('data', (data: Buffer) => console.log(data.toString('utf8').trim()));
-		}
-
-		if (args.verbose) {
-			return new TPromise<void>(c => child.once('exit', () => c(null)));
-		}
-
 		if (args.wait && waitMarkerFilePath) {
 			return new TPromise<void>(c => {
 
@@ -110,8 +266,16 @@ export function main(argv: string[]): TPromise<void> {
 
 				// Complete when wait marker file is deleted
 				whenDeleted(waitMarkerFilePath).done(c, c);
+			}).then(() => {
+
+				// Make sure to delete the tmp stdin file if we have any
+				if (stdinFilePath) {
+					fs.unlinkSync(stdinFilePath);
+				}
 			});
 		}
+
+		return TPromise.join(processCallbacks.map(callback => callback(child)));
 	}
 
 	return TPromise.as(null);

src/vs/code/node/cliProcessMain.ts

@@ -7,7 +7,6 @@ import { localize } from 'vs/nls';
 import product from 'vs/platform/node/product';
 import pkg from 'vs/platform/node/package';
 import * as path from 'path';
-import * as fs from 'fs';
 
 import { TPromise } from 'vs/base/common/winjs.base';
 import { sequence } from 'vs/base/common/async';
@@ -17,9 +16,9 @@ import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';
 import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
-import { EnvironmentService, getInstallSourcePath } from 'vs/platform/environment/node/environmentService';
+import { EnvironmentService } from 'vs/platform/environment/node/environmentService';
 import { IExtensionManagementService, IExtensionGalleryService, IExtensionManifest, IGalleryExtension, LocalExtensionType } from 'vs/platform/extensionManagement/common/extensionManagement';
-import { ExtensionManagementService } from 'vs/platform/extensionManagement/node/extensionManagementService';
+import { ExtensionManagementService, validateLocalExtension } from 'vs/platform/extensionManagement/node/extensionManagementService';
 import { ExtensionGalleryService } from 'vs/platform/extensionManagement/node/extensionGalleryService';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { combinedAppender, NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
@@ -30,9 +29,15 @@ import { RequestService } from 'vs/platform/request/node/requestService';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ConfigurationService } from 'vs/platform/configuration/node/configurationService';
 import { AppInsightsAppender } from 'vs/platform/telemetry/node/appInsightsAppender';
-import { mkdirp } from 'vs/base/node/pfs';
+import { mkdirp, writeFile } from 'vs/base/node/pfs';
 import { IChoiceService } from 'vs/platform/message/common/message';
 import { ChoiceCliService } from 'vs/platform/message/node/messageCli';
+import { getBaseLabel } from 'vs/base/common/labels';
+import { IStateService } from 'vs/platform/state/common/state';
+import { StateService } from 'vs/platform/state/node/stateService';
+import { createLogService } from 'vs/platform/log/node/spdlogService';
+import { ILogService } from 'vs/platform/log/common/log';
+import { isPromiseCanceledError } from 'vs/base/common/errors';
 
 const notFound = (id: string) => localize('notFound', "Extension '{0}' not found.", id);
 const notInstalled = (id: string) => localize('notInstalled', "Extension '{0}' is not installed.", id);
@@ -76,10 +81,7 @@ class Main {
 	}
 
 	private setInstallSource(installSource: string): TPromise<any> {
-		return new TPromise<void>((c, e) => {
-			const path = getInstallSourcePath(this.environmentService.userDataPath);
-			fs.writeFile(path, installSource.slice(0, 30), 'utf8', err => err ? e(err) : c(null));
-		});
+		return writeFile(this.environmentService.installSourcePath, installSource.slice(0, 30));
 	}
 
 	private listExtensions(showVersions: boolean): TPromise<any> {
@@ -95,7 +97,14 @@ class Main {
 				const extension = path.isAbsolute(id) ? id : path.join(process.cwd(), id);
 
 				return this.extensionManagementService.install(extension).then(() => {
-					console.log(localize('successVsixInstall', "Extension '{0}' was successfully installed!", path.basename(extension)));
+					console.log(localize('successVsixInstall', "Extension '{0}' was successfully installed!", getBaseLabel(extension)));
+				}, error => {
+					if (isPromiseCanceledError(error)) {
+						console.log(localize('cancelVsixInstall', "Cancelled installing Extension '{0}'.", getBaseLabel(extension)));
+						return null;
+					} else {
+						return TPromise.wrapError(error);
+					}
 				});
 			});
 
@@ -134,7 +143,16 @@ class Main {
 							console.log(localize('installing', "Installing..."));
 
 							return this.extensionManagementService.installFromGallery(extension)
-								.then(() => console.log(localize('successInstall', "Extension '{0}' v{1} was successfully installed!", id, extension.version)));
+								.then(
+								() => console.log(localize('successInstall', "Extension '{0}' v{1} was successfully installed!", id, extension.version)),
+								error => {
+									if (isPromiseCanceledError(error)) {
+										console.log(localize('cancelVsixInstall', "Cancelled installing Extension '{0}'.", id));
+										return null;
+									} else {
+										return TPromise.wrapError(error);
+									}
+								});
 						});
 				});
 			});
@@ -142,19 +160,31 @@ class Main {
 		return sequence([...vsixTasks, ...galleryTasks]);
 	}
 
-	private uninstallExtension(ids: string[]): TPromise<any> {
-		return sequence(ids.map(id => () => {
-			return this.extensionManagementService.getInstalled(LocalExtensionType.User).then(installed => {
-				const [extension] = installed.filter(e => getId(e.manifest) === id);
+	private uninstallExtension(extensions: string[]): TPromise<any> {
+		async function getExtensionId(extensionDescription: string): TPromise<string> {
+			if (!/\.vsix$/i.test(extensionDescription)) {
+				return extensionDescription;
+			}
 
-				if (!extension) {
-					return TPromise.wrapError(new Error(`${notInstalled(id)}\n${useId}`));
-				}
+			const zipPath = path.isAbsolute(extensionDescription) ? extensionDescription : path.join(process.cwd(), extensionDescription);
+			const manifest = await validateLocalExtension(zipPath);
+			return getId(manifest);
+		}
 
-				console.log(localize('uninstalling', "Uninstalling {0}...", id));
+		return sequence(extensions.map(extension => () => {
+			return getExtensionId(extension).then(id => {
+				return this.extensionManagementService.getInstalled(LocalExtensionType.User).then(installed => {
+					const [extension] = installed.filter(e => getId(e.manifest) === id);
 
-				return this.extensionManagementService.uninstall(extension, true)
-					.then(() => console.log(localize('successUninstall', "Extension '{0}' was successfully uninstalled!", id)));
+					if (!extension) {
+						return TPromise.wrapError(new Error(`${notInstalled(id)}\n${useId}`));
+					}
+
+					console.log(localize('uninstalling', "Uninstalling {0}...", id));
+
+					return this.extensionManagementService.uninstall(extension, true)
+						.then(() => console.log(localize('successUninstall', "Extension '{0}' was successfully uninstalled!", id)));
+				});
 			});
 		}));
 	}
@@ -164,15 +194,25 @@ const eventPrefix = 'monacoworkbench';
 
 export function main(argv: ParsedArgs): TPromise<void> {
 	const services = new ServiceCollection();
-	services.set(IEnvironmentService, new SyncDescriptor(EnvironmentService, argv, process.execPath));
+
+	const environmentService = new EnvironmentService(argv, process.execPath);
+	const logService = createLogService('cli', environmentService);
+	process.once('exit', () => logService.dispose());
+
+	logService.info('main', argv);
+
+	services.set(IEnvironmentService, environmentService);
+	services.set(ILogService, logService);
+	services.set(IStateService, new SyncDescriptor(StateService));
 
 	const instantiationService: IInstantiationService = new InstantiationService(services);
 
 	return instantiationService.invokeFunction(accessor => {
 		const envService = accessor.get(IEnvironmentService);
+		const stateService = accessor.get(IStateService);
 
 		return TPromise.join([envService.appSettingsHome, envService.extensionsPath].map(p => mkdirp(p))).then(() => {
-			const { appRoot, extensionsPath, extensionDevelopmentPath, isBuilt, installSource } = envService;
+			const { appRoot, extensionsPath, extensionDevelopmentPath, isBuilt, installSourcePath } = envService;
 
 			const services = new ServiceCollection();
 			services.set(IConfigurationService, new SyncDescriptor(ConfigurationService));
@@ -194,7 +234,7 @@ export function main(argv: ParsedArgs): TPromise<void> {
 
 				const config: ITelemetryServiceConfig = {
 					appender: combinedAppender(...appenders),
-					commonProperties: resolveCommonProperties(product.commit, pkg.version, installSource),
+					commonProperties: resolveCommonProperties(product.commit, pkg.version, stateService.getItem('telemetry.machineId'), installSourcePath),
 					piiPaths: [appRoot, extensionsPath]
 				};