Merge from master

src/vs/code/node/cli.ts

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 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';
@@ -14,11 +13,13 @@ 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 { findFreePort, randomPort } from 'vs/base/node/ports';
 import { resolveTerminalEncoding } from 'vs/base/node/encoding';
 import * as iconv from 'iconv-lite';
 import { writeFileAndFlushSync } from 'vs/base/node/extfs';
 import { isWindows } from 'vs/base/common/platform';
+import { ProfilingSession, Target } from 'v8-inspect-profiler';
+import { createWaitMarkerFile } from 'vs/code/node/wait';
 
 function shouldSpawnCliProcess(argv: ParsedArgs): boolean {
 	return !!argv['install-source']
@@ -28,7 +29,7 @@ function shouldSpawnCliProcess(argv: ParsedArgs): boolean {
 }
 
 interface IMainCli {
-	main: (argv: ParsedArgs) => TPromise<void>;
+	main: (argv: ParsedArgs) => Thenable<void>;
 }
 
 export async function main(argv: string[]): Promise<any> {
@@ -38,7 +39,7 @@ export async function main(argv: string[]): Promise<any> {
 		args = parseCLIProcessArgv(argv);
 	} catch (err) {
 		console.error(err.message);
-		return TPromise.as(null);
+		return;
 	}
 
 	// Help
@@ -53,8 +54,9 @@ export async function main(argv: string[]): Promise<any> {
 
 	// 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));
+		const cli = await new Promise<IMainCli>((c, e) => require(['vs/code/node/cliProcessMain'], c, e));
+		await cli.main(args);
+		return;
 	}
 
 	// Write File
@@ -69,13 +71,13 @@ export async function main(argv: string[]): Promise<any> {
 			!fs.existsSync(source) || !fs.statSync(source).isFile() ||	// make sure source exists as file
 			!fs.existsSync(target) || !fs.statSync(target).isFile()		// make sure target exists as file
 		) {
-			return TPromise.wrapError(new Error('Using --file-write with invalid arguments.'));
+			throw new Error('Using --file-write with invalid arguments.');
 		}
 
 		try {
 
 			// Check for readonly status and chmod if so if we are told so
-			let targetMode: number;
+			let targetMode: number = 0;
 			let restoreMode = false;
 			if (!!args['file-chmod']) {
 				targetMode = fs.statSync(target).mode;
@@ -87,18 +89,17 @@ export async function main(argv: string[]): Promise<any> {
 
 			// Write source to target
 			const data = fs.readFileSync(source);
-			try {
+			if (isWindows) {
+				// On Windows we use a different strategy of saving the file
+				// by first truncating the file and then writing with r+ mode.
+				// This helps to save hidden files on Windows
+				// (see https://github.com/Microsoft/vscode/issues/931) and
+				// prevent removing alternate data streams
+				// (see https://github.com/Microsoft/vscode/issues/6363)
+				fs.truncateSync(target, 0);
+				writeFileAndFlushSync(target, data, { flag: 'r+' });
+			} else {
 				writeFileAndFlushSync(target, data);
-			} catch (error) {
-				// On Windows and if the file exists with an EPERM error, we try a different strategy of saving the file
-				// by first truncating the file and then writing with r+ mode. This helps to save hidden files on Windows
-				// (see https://github.com/Microsoft/vscode/issues/931)
-				if (isWindows && error.code === 'EPERM') {
-					fs.truncateSync(target, 0);
-					writeFileAndFlushSync(target, data, { flag: 'r+' });
-				} else {
-					throw error;
-				}
 			}
 
 			// Restore previous mode as needed
@@ -106,10 +107,9 @@ export async function main(argv: string[]): Promise<any> {
 				fs.chmodSync(target, targetMode);
 			}
 		} catch (error) {
-			return TPromise.wrapError(new Error(`Using --file-write resulted in an error: ${error}`));
+			error.message = `Error using --file-write: ${error.message}`;
+			throw error;
 		}
-
-		return TPromise.as(null);
 	}
 
 	// Just Code
@@ -127,15 +127,15 @@ export async function main(argv: string[]): Promise<any> {
 		if (verbose) {
 			env['ELECTRON_ENABLE_LOGGING'] = '1';
 
-			processCallbacks.push(child => {
+			processCallbacks.push(async 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)));
+				await new Promise(c => child.once('exit', () => c()));
 			});
 		}
 
-		let stdinWithoutTty: boolean;
+		let stdinWithoutTty: boolean = false;
 		try {
 			stdinWithoutTty = !process.stdin.isTTY; // Via https://twitter.com/MylesBorins/status/782009479382626304
 		} catch (error) {
@@ -161,7 +161,7 @@ export async function main(argv: string[]): Promise<any> {
 				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 stdinFileError: Error | undefined;
 				let stdinFileStream: fs.WriteStream;
 				try {
 					stdinFileStream = fs.createWriteStream(stdinFilePath);
@@ -172,7 +172,7 @@ export async function main(argv: string[]): Promise<any> {
 				if (!stdinFileError) {
 
 					// Pipe into tmp file using terminals encoding
-					resolveTerminalEncoding(verbose).done(encoding => {
+					resolveTerminalEncoding(verbose).then(encoding => {
 						const converterStream = iconv.decodeStream(encoding);
 						process.stdin.pipe(converterStream).pipe(stdinFileStream);
 					});
@@ -198,7 +198,7 @@ export async function main(argv: string[]): Promise<any> {
 			// 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 => {
+				processCallbacks.push(child => new Promise(c => {
 					const dataListener = () => {
 						if (isWindows) {
 							console.log(`Run with '${product.applicationName} -' to read output from another program (e.g. 'echo Hello World | ${product.applicationName} -').`);
@@ -226,24 +226,11 @@ export async function main(argv: string[]): Promise<any> {
 		// and pass it over to the starting instance. We can use this file
 		// to wait for it to be deleted to monitor that the edited file
 		// is closed and then exit the waiting process.
-		let waitMarkerFilePath: string;
+		let waitMarkerFilePath: string | undefined;
 		if (args.wait) {
-			let waitMarkerError: Error;
-			const randomTmpFile = paths.join(os.tmpdir(), Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 10));
-			try {
-				fs.writeFileSync(randomTmpFile, '');
-				waitMarkerFilePath = randomTmpFile;
+			waitMarkerFilePath = await createWaitMarkerFile(verbose);
+			if (waitMarkerFilePath) {
 				argv.push('--waitMarkerFilePath', waitMarkerFilePath);
-			} catch (error) {
-				waitMarkerError = error;
-			}
-
-			if (verbose) {
-				if (waitMarkerError) {
-					console.error(`Failed to create marker file for --wait: ${waitMarkerError.toString()}`);
-				} else {
-					console.log(`Marker file for --wait created: ${waitMarkerFilePath}`);
-				}
 			}
 		}
 
@@ -252,16 +239,16 @@ export async function main(argv: string[]): Promise<any> {
 		// 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);
+			const portMain = await findFreePort(randomPort(), 10, 3000);
+			const portRenderer = await findFreePort(portMain + 1, 10, 3000);
+			const portExthost = await findFreePort(portRenderer + 1, 10, 3000);
 
-			if (!portMain || !portRenderer || !portExthost) {
-				console.error('Failed to find free ports for profiler to connect to do.');
-				return;
+			// fail the operation when one of the ports couldn't be accquired.
+			if (portMain * portRenderer * portExthost === 0) {
+				throw new Error('Failed to find free ports for profiler. Make sure to shutdown all instances of the editor first.');
 			}
 
-			const filenamePrefix = paths.join(os.homedir(), Math.random().toString(16).slice(-4));
+			const filenamePrefix = paths.join(os.homedir(), 'prof-' + Math.random().toString(16).slice(-4));
 
 			argv.push(`--inspect-brk=${portMain}`);
 			argv.push(`--remote-debugging-port=${portRenderer}`);
@@ -271,38 +258,81 @@ export async function main(argv: string[]): Promise<any> {
 
 			fs.writeFileSync(filenamePrefix, argv.slice(-6).join('|'));
 
-			processCallbacks.push(async child => {
+			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 });
+				class Profiler {
+					static async start(name: string, filenamePrefix: string, opts: { port: number, tries?: number, target?: (targets: Target[]) => Target }) {
+						const profiler = await import('v8-inspect-profiler');
 
-				// wait for the renderer to delete the
-				// marker file
-				whenDeleted(filenamePrefix);
+						let session: ProfilingSession;
+						try {
+							session = await profiler.startProfiling(opts);
+						} catch (err) {
+							console.error(`FAILED to start profiling for '${name}' on port '${opts.port}'`);
+						}
 
-				let profileMain = await main.stop();
-				let profileRenderer = await renderer.stop();
-				let profileExtHost = await extHost.stop();
-				let suffix = '';
+						return {
+							async stop() {
+								if (!session) {
+									return;
+								}
+								let suffix = '';
+								let profile = await session.stop();
+								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
+									profile = profiler.rewriteAbsolutePaths(profile, 'piiRemoved');
+									suffix = '.txt';
+								}
 
-				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';
+								await profiler.writeProfile(profile, `${filenamePrefix}.${name}.cpuprofile${suffix}`);
+							}
+						};
+					}
 				}
 
-				// 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}`);
+				try {
+					// load and start profiler
+					const mainProfileRequest = Profiler.start('main', filenamePrefix, { port: portMain });
+					const extHostProfileRequest = Profiler.start('extHost', filenamePrefix, { port: portExthost, tries: 300 });
+					const rendererProfileRequest = Profiler.start('renderer', filenamePrefix, {
+						port: portRenderer,
+						tries: 200,
+						target: function (targets) {
+							return targets.filter(target => {
+								if (!target.webSocketDebuggerUrl) {
+									return false;
+								}
+								if (target.type === 'page') {
+									return target.url.indexOf('workbench/workbench.html') > 0;
+								} else {
+									return true;
+								}
+							})[0];
+						}
+					});
+
+					const main = await mainProfileRequest;
+					const extHost = await extHostProfileRequest;
+					const renderer = await rendererProfileRequest;
+
+					// wait for the renderer to delete the
+					// marker file
+					await whenDeleted(filenamePrefix);
+
+					// stop profiling
+					await main.stop();
+					await renderer.stop();
+					await extHost.stop();
+
+					// re-create the marker file to signal that profiling is done
+					fs.writeFileSync(filenamePrefix, '');
+
+				} catch (e) {
+					console.error('Failed to profile startup. Make sure to quit Code first.');
+				}
 			});
 		}
 
@@ -327,13 +357,13 @@ export async function main(argv: string[]): Promise<any> {
 		const child = spawn(process.execPath, argv.slice(2), options);
 
 		if (args.wait && waitMarkerFilePath) {
-			return new TPromise<void>(c => {
+			return new Promise<void>(c => {
 
 				// Complete when process exits
-				child.once('exit', () => c(null));
+				child.once('exit', () => c(void 0));
 
 				// Complete when wait marker file is deleted
-				whenDeleted(waitMarkerFilePath).done(c, c);
+				whenDeleted(waitMarkerFilePath!).then(c, c);
 			}).then(() => {
 
 				// Make sure to delete the tmp stdin file if we have any
@@ -343,10 +373,8 @@ export async function main(argv: string[]): Promise<any> {
 			});
 		}
 
-		return TPromise.join(processCallbacks.map(callback => callback(child)));
+		return Promise.all(processCallbacks.map(callback => callback(child)));
 	}
-
-	return TPromise.as(null);
 }
 
 function eventuallyExit(code: number): void {

src/vs/code/node/cliProcessMain.ts

@@ -11,7 +11,6 @@ import * as semver from 'semver';
 
 import { TPromise } from 'vs/base/common/winjs.base';
 import { sequence } from 'vs/base/common/async';
-import { IPager } from 'vs/base/common/paging';
 import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
 import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -19,7 +18,7 @@ import { InstantiationService } from 'vs/platform/instantiation/common/instantia
 import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
 import { EnvironmentService } from 'vs/platform/environment/node/environmentService';
 import { IExtensionManagementService, IExtensionGalleryService, IExtensionManifest, IGalleryExtension, LocalExtensionType } from 'vs/platform/extensionManagement/common/extensionManagement';
-import { ExtensionManagementService, validateLocalExtension } from 'vs/platform/extensionManagement/node/extensionManagementService';
+import { ExtensionManagementService } 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';
@@ -37,10 +36,9 @@ import { StateService } from 'vs/platform/state/node/stateService';
 import { createSpdLogService } from 'vs/platform/log/node/spdlogService';
 import { ILogService, getLogLevel } from 'vs/platform/log/common/log';
 import { isPromiseCanceledError } from 'vs/base/common/errors';
-import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
-import { CommandLineDialogService } from 'vs/platform/dialogs/node/dialogService';
-import { areSameExtensions, getGalleryExtensionIdFromLocal } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
-import Severity from 'vs/base/common/severity';
+import { areSameExtensions, getGalleryExtensionIdFromLocal, adoptToGalleryExtensionId, getGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { URI } from 'vs/base/common/uri';
+import { getManifest } from 'vs/platform/extensionManagement/node/extensionManagementUtil';
 
 const notFound = (id: string) => localize('notFound', "Extension '{0}' not found.", id);
 const notInstalled = (id: string) => localize('notInstalled', "Extension '{0}' is not installed.", id);
@@ -54,6 +52,17 @@ function getId(manifest: IExtensionManifest, withVersion?: boolean): string {
 	}
 }
 
+const EXTENSION_ID_REGEX = /^([^.]+\..+)@(\d+\.\d+\.\d+(-.*)?)$/;
+
+export function getIdAndVersion(id: string): [string, string] {
+	const matches = EXTENSION_ID_REGEX.exec(id);
+	if (matches && matches[1]) {
+		return [adoptToGalleryExtensionId(matches[1]), matches[2]];
+	}
+	return [adoptToGalleryExtensionId(id), void 0];
+}
+
+
 type Task = { (): TPromise<void> };
 
 class Main {
@@ -61,8 +70,7 @@ class Main {
 	constructor(
 		@IEnvironmentService private environmentService: IEnvironmentService,
 		@IExtensionManagementService private extensionManagementService: IExtensionManagementService,
-		@IExtensionGalleryService private extensionGalleryService: IExtensionGalleryService,
-		@IDialogService private dialogService: IDialogService
+		@IExtensionGalleryService private extensionGalleryService: IExtensionGalleryService
 	) { }
 
 	run(argv: ParsedArgs): TPromise<any> {
@@ -76,7 +84,7 @@ class Main {
 		} else if (argv['install-extension']) {
 			const arg = argv['install-extension'];
 			const args: string[] = typeof arg === 'string' ? [arg] : arg;
-			returnPromise = this.installExtension(args);
+			returnPromise = this.installExtension(args, argv['force']);
 		} else if (argv['uninstall-extension']) {
 			const arg = argv['uninstall-extension'];
 			const ids: string[] = typeof arg === 'string' ? [arg] : arg;
@@ -95,30 +103,36 @@ class Main {
 		});
 	}
 
-	private installExtension(extensions: string[]): TPromise<any> {
+	private installExtension(extensions: string[], force: boolean): TPromise<any> {
 		const vsixTasks: Task[] = extensions
 			.filter(e => /\.vsix$/i.test(e))
 			.map(id => () => {
 				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!", getBaseLabel(extension)));
-				}, error => {
-					if (isPromiseCanceledError(error)) {
-						console.log(localize('cancelVsixInstall', "Cancelled installing Extension '{0}'.", getBaseLabel(extension)));
+				return this.validate(extension, force)
+					.then(valid => {
+						if (valid) {
+							return this.extensionManagementService.install(URI.file(extension)).then(() => {
+								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);
+								}
+							});
+						}
 						return null;
-					} else {
-						return TPromise.wrapError(error);
-					}
-				});
+					});
 			});
 
 		const galleryTasks: Task[] = extensions
 			.filter(e => !/\.vsix$/i.test(e))
-			.map(id => () => {
+			.map(e => () => {
+				const [id, version] = getIdAndVersion(e);
 				return this.extensionManagementService.getInstalled(LocalExtensionType.User)
-					.then(installed => this.extensionGalleryService.query({ names: [id], source: 'cli' })
-						.then<IPager<IGalleryExtension>>(null, err => {
+					.then(installed => this.extensionGalleryService.getExtension({ id }, version)
+						.then<IGalleryExtension>(null, err => {
 							if (err.responseText) {
 								try {
 									const response = JSON.parse(err.responseText);
@@ -129,29 +143,23 @@ class Main {
 							}
 							return TPromise.wrapError(err);
 						})
-						.then(result => {
-							const [extension] = result.firstPage;
-
+						.then(extension => {
 							if (!extension) {
-								return TPromise.wrapError(new Error(`${notFound(id)}\n${useId}`));
+								return TPromise.wrapError(new Error(`${notFound(version ? `${id}@${version}` : id)}\n${useId}`));
 							}
 
 							const [installedExtension] = installed.filter(e => areSameExtensions({ id: getGalleryExtensionIdFromLocal(e) }, { id }));
 							if (installedExtension) {
-								const outdated = semver.gt(extension.version, installedExtension.manifest.version);
-								if (outdated) {
-									const updateMessage = localize('updateMessage', "Extension '{0}' v{1} is already installed, but a newer version {2} is available in the marketplace. Would you like to update?", id, installedExtension.manifest.version, extension.version);
-									return this.dialogService.show(Severity.Info, updateMessage, [localize('yes', "Yes"), localize('no', "No")])
-										.then(option => {
-											if (option === 0) {
-												return this.installFromGallery(id, extension);
-											}
-											console.log(localize('cancelInstall', "Cancelled installing Extension '{0}'.", id));
-											return TPromise.as(null);
-										});
-
+								if (extension.version !== installedExtension.manifest.version) {
+									if (version || force) {
+										console.log(localize('updateMessage', "Updating the Extension '{0}' to the version {1}", id, extension.version));
+										return this.installFromGallery(id, extension);
+									} else {
+										console.log(localize('forceUpdate', "Extension '{0}' v{1} is already installed, but a newer version {2} is available in the marketplace. Use '--force' option to update to newer version.", id, installedExtension.manifest.version, extension.version));
+										return Promise.resolve(null);
+									}
 								} else {
-									console.log(localize('alreadyInstalled', "Extension '{0}' is already installed.", id));
+									console.log(localize('alreadyInstalled', "Extension '{0}' is already installed.", version ? `${id}@${version}` : id));
 									return TPromise.as(null);
 								}
 							} else {
@@ -165,6 +173,26 @@ class Main {
 		return sequence([...vsixTasks, ...galleryTasks]);
 	}
 
+	private validate(vsix: string, force: boolean): Thenable<boolean> {
+		return getManifest(vsix)
+			.then(manifest => {
+				if (manifest) {
+					const extensionIdentifier = { id: getGalleryExtensionId(manifest.publisher, manifest.name) };
+					return this.extensionManagementService.getInstalled(LocalExtensionType.User)
+						.then(installedExtensions => {
+							const newer = installedExtensions.filter(local => areSameExtensions(extensionIdentifier, { id: getGalleryExtensionIdFromLocal(local) }) && semver.gt(local.manifest.version, manifest.version))[0];
+							if (newer && !force) {
+								console.log(localize('forceDowngrade', "A newer version of this extension '{0}' v{1} is already installed. Use '--force' option to downgrade to older version.", newer.galleryIdentifier.id, newer.manifest.version, manifest.version));
+								return false;
+							}
+							return true;
+						});
+				} else {
+					return Promise.reject(new Error('Invalid vsix'));
+				}
+			});
+	}
+
 	private installFromGallery(id: string, extension: IGalleryExtension): TPromise<void> {
 		console.log(localize('installing', "Installing..."));
 		return this.extensionManagementService.installFromGallery(extension)
@@ -187,7 +215,7 @@ class Main {
 			}
 
 			const zipPath = path.isAbsolute(extensionDescription) ? extensionDescription : path.join(process.cwd(), extensionDescription);
-			const manifest = await validateLocalExtension(zipPath);
+			const manifest = await getManifest(zipPath);
 			return getId(manifest);
 		}
 
@@ -232,17 +260,16 @@ export function main(argv: ParsedArgs): TPromise<void> {
 		const stateService = accessor.get(IStateService);
 
 		return TPromise.join([envService.appSettingsHome, envService.extensionsPath].map(p => mkdirp(p))).then(() => {
-			const { appRoot, extensionsPath, extensionDevelopmentPath, isBuilt, installSourcePath } = envService;
+			const { appRoot, extensionsPath, extensionDevelopmentLocationURI, isBuilt, installSourcePath } = envService;
 
 			const services = new ServiceCollection();
 			services.set(IConfigurationService, new SyncDescriptor(ConfigurationService));
 			services.set(IRequestService, new SyncDescriptor(RequestService));
 			services.set(IExtensionManagementService, new SyncDescriptor(ExtensionManagementService));
 			services.set(IExtensionGalleryService, new SyncDescriptor(ExtensionGalleryService));
-			services.set(IDialogService, new SyncDescriptor(CommandLineDialogService));
 
 			const appenders: AppInsightsAppender[] = [];
-			if (isBuilt && !extensionDevelopmentPath && !envService.args['disable-telemetry'] && product.enableTelemetry) {
+			if (isBuilt && !extensionDevelopmentLocationURI && !envService.args['disable-telemetry'] && product.enableTelemetry) {
 
 				if (product.aiConfig && product.aiConfig.asimovKey) {
 					appenders.push(new AppInsightsAppender(eventPrefix, null, product.aiConfig.asimovKey, logService));
@@ -254,7 +281,7 @@ export function main(argv: ParsedArgs): TPromise<void> {
 					piiPaths: [appRoot, extensionsPath]
 				};
 
-				services.set(ITelemetryService, new SyncDescriptor(TelemetryService, config));
+				services.set(ITelemetryService, new SyncDescriptor(TelemetryService, [config]));
 			} else {
 				services.set(ITelemetryService, NullTelemetryService);
 			}

src/vs/code/node/paths.ts

@@ -3,8 +3,6 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-'use strict';
-
 import * as path from 'path';
 import * as arrays from 'vs/base/common/arrays';
 import * as strings from 'vs/base/common/strings';
@@ -12,16 +10,17 @@ import * as paths from 'vs/base/common/paths';
 import * as platform from 'vs/base/common/platform';
 import * as types from 'vs/base/common/types';
 import { ParsedArgs } from 'vs/platform/environment/common/environment';
-import { realpathSync } from 'vs/base/node/extfs';
+import { sanitizeFilePath } from 'vs/base/node/extfs';
 
 export function validatePaths(args: ParsedArgs): ParsedArgs {
+
 	// Track URLs if they're going to be used
 	if (args['open-url']) {
 		args._urls = args._;
 		args._ = [];
 	}
 
-	// Realpath/normalize paths and watch out for goto line mode
+	// Normalize paths and watch out for goto line mode
 	const paths = doValidatePaths(args._, args.goto);
 
 	// Update environment
@@ -36,7 +35,7 @@ function doValidatePaths(args: string[], gotoLineMode?: boolean): string[] {
 	const result = args.map(arg => {
 		let pathCandidate = String(arg);
 
-		let parsedPath: IPathWithLineAndColumn;
+		let parsedPath: IPathWithLineAndColumn | undefined = undefined;
 		if (gotoLineMode) {
 			parsedPath = parseLineAndColumnAware(pathCandidate);
 			pathCandidate = parsedPath.path;
@@ -46,30 +45,24 @@ function doValidatePaths(args: string[], gotoLineMode?: boolean): string[] {
 			pathCandidate = preparePath(cwd, pathCandidate);
 		}
 
-		let realPath: string;
-		try {
-			realPath = realpathSync(pathCandidate);
-		} catch (error) {
-			// in case of an error, assume the user wants to create this file
-			// if the path is relative, we join it to the cwd
-			realPath = path.normalize(path.isAbsolute(pathCandidate) ? pathCandidate : path.join(cwd, pathCandidate));
-		}
+		const sanitizedFilePath = sanitizeFilePath(pathCandidate, cwd);
 
-		const basename = path.basename(realPath);
+		const basename = path.basename(sanitizedFilePath);
 		if (basename /* can be empty if code is opened on root */ && !paths.isValidBasename(basename)) {
 			return null; // do not allow invalid file names
 		}
 
-		if (gotoLineMode) {
-			parsedPath.path = realPath;
+		if (gotoLineMode && parsedPath) {
+			parsedPath.path = sanitizedFilePath;
+
 			return toPath(parsedPath);
 		}
 
-		return realPath;
+		return sanitizedFilePath;
 	});
 
 	const caseInsensitive = platform.isWindows || platform.isMacintosh;
-	const distinct = arrays.distinct(result, e => e && caseInsensitive ? e.toLowerCase() : e);
+	const distinct = arrays.distinct(result, e => e && caseInsensitive ? e.toLowerCase() : (e || ''));
 
 	return arrays.coalesce(distinct);
 }
@@ -105,9 +98,9 @@ export interface IPathWithLineAndColumn {
 export function parseLineAndColumnAware(rawPath: string): IPathWithLineAndColumn {
 	const segments = rawPath.split(':'); // C:\file.txt:<line>:<column>
 
-	let path: string;
-	let line: number = null;
-	let column: number = null;
+	let path: string | null = null;
+	let line: number | null = null;
+	let column: number | null = null;
 
 	segments.forEach(segment => {
 		const segmentAsNumber = Number(segment);

src/vs/code/node/shellEnv.ts

@@ -3,16 +3,13 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-'use strict';
-
 import * as cp from 'child_process';
 import { assign } from 'vs/base/common/objects';
 import { generateUuid } from 'vs/base/common/uuid';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { isWindows } from 'vs/base/common/platform';
 
-function getUnixShellEnvironment(): TPromise<typeof process.env> {
-	const promise = new TPromise((c, e) => {
+function getUnixShellEnvironment(): Promise<typeof process.env> {
+	const promise = new Promise((resolve, reject) => {
 		const runAsNode = process.env['ELECTRON_RUN_AS_NODE'];
 		const noAttach = process.env['ELECTRON_NO_ATTACH_CONSOLE'];
 		const mark = generateUuid().replace(/-/g, '').substr(0, 12);
@@ -24,19 +21,19 @@ function getUnixShellEnvironment(): TPromise<typeof process.env> {
 		});
 
 		const command = `'${process.execPath}' -p '"${mark}" + JSON.stringify(process.env) + "${mark}"'`;
-		const child = cp.spawn(process.env.SHELL, ['-ilc', command], {
+		const child = cp.spawn(process.env.SHELL!, ['-ilc', command], {
 			detached: true,
 			stdio: ['ignore', 'pipe', process.stderr],
 			env
 		});
 
 		const buffers: Buffer[] = [];
-		child.on('error', () => c({}));
+		child.on('error', () => resolve({}));
 		child.stdout.on('data', b => buffers.push(b as Buffer));
 
 		child.on('close', (code: number, signal: any) => {
 			if (code !== 0) {
-				return e(new Error('Failed to get environment'));
+				return reject(new Error('Failed to get environment'));
 			}
 
 			const raw = Buffer.concat(buffers).toString('utf8');
@@ -61,31 +58,31 @@ function getUnixShellEnvironment(): TPromise<typeof process.env> {
 				// https://github.com/Microsoft/vscode/issues/22593#issuecomment-336050758
 				delete env['XDG_RUNTIME_DIR'];
 
-				c(env);
+				resolve(env);
 			} catch (err) {
-				e(err);
+				reject(err);
 			}
 		});
 	});
 
 	// swallow errors
-	return promise.then(null, () => ({}));
+	return promise.then(undefined, () => ({}));
 }
 
 
-let _shellEnv: TPromise<typeof process.env>;
+let _shellEnv: Promise<typeof process.env>;
 
 /**
  * We need to get the environment from a user's shell.
  * This should only be done when Code itself is not launched
  * from within a shell.
  */
-export function getShellEnvironment(): TPromise<typeof process.env> {
+export function getShellEnvironment(): Promise<typeof process.env> {
 	if (_shellEnv === undefined) {
 		if (isWindows) {
-			_shellEnv = TPromise.as({});
+			_shellEnv = Promise.resolve({});
 		} else if (process.env['VSCODE_CLI'] === '1') {
-			_shellEnv = TPromise.as({});
+			_shellEnv = Promise.resolve({});
 		} else {
 			_shellEnv = getUnixShellEnvironment();
 		}

src/vs/code/node/wait.ts

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { writeFile } from 'vs/base/node/pfs';
+
+export function createWaitMarkerFile(verbose?: boolean): Promise<string> {
+	const randomWaitMarkerPath = join(tmpdir(), Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 10));
+
+	return writeFile(randomWaitMarkerPath, '').then(() => {
+		if (verbose) {
+			console.log(`Marker file for --wait created: ${randomWaitMarkerPath}`);
+		}
+
+		return randomWaitMarkerPath;
+	}, error => {
+		if (verbose) {
+			console.error(`Failed to create marker file for --wait: ${error}`);
+		}
+
+		return Promise.resolve(void 0);
+	});
+}

src/vs/code/node/windowsFinder.ts

@@ -3,20 +3,17 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-'use strict';
-
 import * as platform from 'vs/base/common/platform';
 import * as paths from 'vs/base/common/paths';
 import { OpenContext } from 'vs/platform/windows/common/windows';
-import { IWorkspaceIdentifier, IResolvedWorkspace, ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
-import { Schemas } from 'vs/base/common/network';
-import URI from 'vs/base/common/uri';
-import { hasToIgnoreCase, isEqual } from 'vs/base/common/resources';
+import { IWorkspaceIdentifier, IResolvedWorkspace, ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
+import { URI } from 'vs/base/common/uri';
+import { isEqual, isEqualOrParent } from 'vs/base/common/resources';
 
 export interface ISimpleWindow {
 	openedWorkspace?: IWorkspaceIdentifier;
 	openedFolderUri?: URI;
-	openedFilePath?: string;
+
 	extensionDevelopmentPath?: string;
 	lastFocusTime: number;
 }
@@ -26,39 +23,38 @@ export interface IBestWindowOrFolderOptions<W extends ISimpleWindow> {
 	newWindow: boolean;
 	reuseWindow: boolean;
 	context: OpenContext;
-	filePath?: string;
+	fileUri?: URI;
 	userHome?: string;
 	codeSettingsFolder?: string;
 	workspaceResolver: (workspace: IWorkspaceIdentifier) => IResolvedWorkspace;
 }
 
-export function findBestWindowOrFolderForFile<W extends ISimpleWindow>({ windows, newWindow, reuseWindow, context, filePath, workspaceResolver }: IBestWindowOrFolderOptions<W>): W {
-	if (!newWindow && filePath && (context === OpenContext.DESKTOP || context === OpenContext.CLI || context === OpenContext.DOCK)) {
-		const windowOnFilePath = findWindowOnFilePath(windows, filePath, workspaceResolver);
+export function findBestWindowOrFolderForFile<W extends ISimpleWindow>({ windows, newWindow, reuseWindow, context, fileUri, workspaceResolver }: IBestWindowOrFolderOptions<W>): W | null {
+	if (!newWindow && fileUri && (context === OpenContext.DESKTOP || context === OpenContext.CLI || context === OpenContext.DOCK)) {
+		const windowOnFilePath = findWindowOnFilePath(windows, fileUri, workspaceResolver);
 		if (windowOnFilePath) {
 			return windowOnFilePath;
 		}
 	}
-
 	return !newWindow ? getLastActiveWindow(windows) : null;
 }
 
-function findWindowOnFilePath<W extends ISimpleWindow>(windows: W[], filePath: string, workspaceResolver: (workspace: IWorkspaceIdentifier) => IResolvedWorkspace): W {
+function findWindowOnFilePath<W extends ISimpleWindow>(windows: W[], fileUri: URI, workspaceResolver: (workspace: IWorkspaceIdentifier) => IResolvedWorkspace): W | null {
 
 	// First check for windows with workspaces that have a parent folder of the provided path opened
 	const workspaceWindows = windows.filter(window => !!window.openedWorkspace);
 	for (let i = 0; i < workspaceWindows.length; i++) {
 		const window = workspaceWindows[i];
-		const resolvedWorkspace = workspaceResolver(window.openedWorkspace);
-		if (resolvedWorkspace && resolvedWorkspace.folders.some(folder => folder.uri.scheme === Schemas.file && paths.isEqualOrParent(filePath, folder.uri.fsPath, !platform.isLinux /* ignorecase */))) {
+		const resolvedWorkspace = workspaceResolver(window.openedWorkspace!);
+		if (resolvedWorkspace && resolvedWorkspace.folders.some(folder => isEqualOrParent(fileUri, folder.uri))) {
 			return window;
 		}
 	}
 
 	// Then go with single folder windows that are parent of the provided file path
-	const singleFolderWindowsOnFilePath = windows.filter(window => window.openedFolderUri && window.openedFolderUri.scheme === Schemas.file && paths.isEqualOrParent(filePath, window.openedFolderUri.fsPath, !platform.isLinux /* ignorecase */));
+	const singleFolderWindowsOnFilePath = windows.filter(window => window.openedFolderUri && isEqualOrParent(fileUri, window.openedFolderUri));
 	if (singleFolderWindowsOnFilePath.length) {
-		return singleFolderWindowsOnFilePath.sort((a, b) => -(a.openedFolderUri.path.length - b.openedFolderUri.path.length))[0];
+		return singleFolderWindowsOnFilePath.sort((a, b) => -(a.openedFolderUri!.path.length - b.openedFolderUri!.path.length))[0];
 	}
 
 	return null;
@@ -70,52 +66,51 @@ export function getLastActiveWindow<W extends ISimpleWindow>(windows: W[]): W {
 	return windows.filter(window => window.lastFocusTime === lastFocusedDate)[0];
 }
 
-export function findWindowOnWorkspace<W extends ISimpleWindow>(windows: W[], workspace: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier)): W {
-	return windows.filter(window => {
-
-		// match on folder
-		if (isSingleFolderWorkspaceIdentifier(workspace)) {
-			if (window.openedFolderUri && isEqual(window.openedFolderUri, workspace, hasToIgnoreCase(window.openedFolderUri))) {
-				return true;
+export function findWindowOnWorkspace<W extends ISimpleWindow>(windows: W[], workspace: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier)): W | null {
+	if (isSingleFolderWorkspaceIdentifier(workspace)) {
+		for (const window of windows) {
+			// match on folder
+			if (isSingleFolderWorkspaceIdentifier(workspace)) {
+				if (window.openedFolderUri && isEqual(window.openedFolderUri, workspace)) {
+					return window;
+				}
 			}
 		}
-
-		// match on workspace
-		else {
+	} else if (isWorkspaceIdentifier(workspace)) {
+		for (const window of windows) {
+			// match on workspace
 			if (window.openedWorkspace && window.openedWorkspace.id === workspace.id) {
-				return true;
+				return window;
 			}
 		}
-
-		return false;
-	})[0];
+	}
+	return null;
 }
 
-export function findWindowOnExtensionDevelopmentPath<W extends ISimpleWindow>(windows: W[], extensionDevelopmentPath: string): W {
-	return windows.filter(window => {
-
-		// match on extension development path
-		if (paths.isEqual(window.extensionDevelopmentPath, extensionDevelopmentPath, !platform.isLinux /* ignorecase */)) {
-			return true;
+export function findWindowOnExtensionDevelopmentPath<W extends ISimpleWindow>(windows: W[], extensionDevelopmentPath: string): W | null {
+	for (const window of windows) {
+		// match on extension development path. The path can be a path or uri string, using paths.isEqual is not 100% correct but good enough
+		if (window.extensionDevelopmentPath && paths.isEqual(window.extensionDevelopmentPath, extensionDevelopmentPath, !platform.isLinux /* ignorecase */)) {
+			return window;
 		}
-
-		return false;
-	})[0];
+	}
+	return null;
 }
 
-export function findWindowOnWorkspaceOrFolderUri<W extends ISimpleWindow>(windows: W[], uri: URI): W {
-	return windows.filter(window => {
-
+export function findWindowOnWorkspaceOrFolderUri<W extends ISimpleWindow>(windows: W[], uri: URI): W | null {
+	if (!uri) {
+		return null;
+	}
+	for (const window of windows) {
 		// check for workspace config path
 		if (window.openedWorkspace && isEqual(URI.file(window.openedWorkspace.configPath), uri, !platform.isLinux /* ignorecase */)) {
-			return true;
+			return window;
 		}
 
 		// check for folder path
-		if (window.openedFolderUri && isEqual(window.openedFolderUri, uri, hasToIgnoreCase(uri))) {
-			return true;
+		if (window.openedFolderUri && isEqual(window.openedFolderUri, uri)) {
+			return window;
 		}
-
-		return false;
-	})[0];
+	}
+	return null;
 }