Merge VS Code 1.31.1 (#4283)

2026-02-03 01:25:38 -05:00 · 2019-03-15 13:09:45 -07:00
parent 7d31575149
commit 86bac90001
1716 changed files with 53308 additions and 48375 deletions
--- a/src/vs/workbench/api/electron-browser/extensionHost.contribution.ts
+++ b/src/vs/workbench/api/electron-browser/extensionHost.contribution.ts
@@ -18,10 +18,10 @@ import 'vs/workbench/api/node/apiCommands';
 import './mainThreadClipboard';
 import './mainThreadCommands';
 import './mainThreadConfiguration';
+import './mainThreadConsole';
 // {{SQL CARBON EDIT}}
 // disable the debug service
 // import './mainThreadDebugService';
-
 import './mainThreadDecorations';
 import './mainThreadDiagnostics';
 import './mainThreadDialogs';
@@ -60,7 +60,7 @@ import './mainThreadWorkspace';
 export class ExtensionPoints implements IWorkbenchContribution {

 	constructor(
-		@IInstantiationService private instantiationService: IInstantiationService
+		@IInstantiationService private readonly instantiationService: IInstantiationService
 	) {
 		// Classes that handle extension points...
 		this.instantiationService.createInstance(JSONValidationExtensionPoint);
--- a/src/vs/workbench/api/electron-browser/mainThreadCommands.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadCommands.ts
@@ -32,7 +32,7 @@ export class MainThreadCommands implements MainThreadCommandsShape {
 		this._generateCommandsDocumentationRegistration.dispose();
 	}

-	private _generateCommandsDocumentation(): Thenable<void> {
+	private _generateCommandsDocumentation(): Promise<void> {
 		return this._proxy.$getContributedCommandHandlerDescriptions().then(result => {
 			// add local commands
 			const commands = CommandsRegistry.getCommands();
@@ -70,14 +70,14 @@ export class MainThreadCommands implements MainThreadCommandsShape {
 		}
 	}

-	$executeCommand<T>(id: string, args: any[]): Thenable<T> {
+	$executeCommand<T>(id: string, args: any[]): Promise<T> {
 		for (let i = 0; i < args.length; i++) {
 			args[i] = revive(args[i], 0);
 		}
 		return this._commandService.executeCommand<T>(id, ...args);
 	}

-	$getCommands(): Thenable<string[]> {
+	$getCommands(): Promise<string[]> {
 		return Promise.resolve(Object.keys(CommandsRegistry.getCommands()));
 	}
 }
--- a/src/vs/workbench/api/electron-browser/mainThreadComments.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadComments.ts
@@ -12,11 +12,16 @@ import { IEditorService } from 'vs/workbench/services/editor/common/editorServic
 import { ExtHostCommentsShape, ExtHostContext, IExtHostContext, MainContext, MainThreadCommentsShape, CommentProviderFeatures } from '../node/extHost.protocol';

 import { ICommentService } from 'vs/workbench/parts/comments/electron-browser/commentService';
-import { COMMENTS_PANEL_ID } from 'vs/workbench/parts/comments/electron-browser/commentsPanel';
+import { COMMENTS_PANEL_ID, CommentsPanel, COMMENTS_PANEL_TITLE } from 'vs/workbench/parts/comments/electron-browser/commentsPanel';
 import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { URI } from 'vs/base/common/uri';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { generateUuid } from 'vs/base/common/uuid';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { ICommentsConfiguration } from 'vs/workbench/parts/comments/electron-browser/comments.contribution';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { PanelRegistry, Extensions as PanelExtensions, PanelDescriptor } from 'vs/workbench/browser/panel';

 export class MainThreadDocumentCommentProvider implements modes.DocumentCommentProvider {
 	private _proxy: ExtHostCommentsShape;
@@ -25,6 +30,7 @@ export class MainThreadDocumentCommentProvider implements modes.DocumentCommentP
 	get startDraftLabel(): string { return this._features.startDraftLabel; }
 	get deleteDraftLabel(): string { return this._features.deleteDraftLabel; }
 	get finishDraftLabel(): string { return this._features.finishDraftLabel; }
+	get reactionGroup(): modes.CommentReaction[] { return this._features.reactionGroup; }

 	constructor(proxy: ExtHostCommentsShape, handle: number, features: CommentProviderFeatures) {
 		this._proxy = proxy;
@@ -52,15 +58,22 @@ export class MainThreadDocumentCommentProvider implements modes.DocumentCommentP
 		return this._proxy.$deleteComment(this._handle, uri, comment);
 	}

-	async startDraft(token): Promise<void> {
-		return this._proxy.$startDraft(this._handle);
+	async startDraft(uri, token): Promise<void> {
+		return this._proxy.$startDraft(this._handle, uri);
 	}
-	async deleteDraft(token): Promise<void> {
-		return this._proxy.$deleteDraft(this._handle);
+	async deleteDraft(uri, token): Promise<void> {
+		return this._proxy.$deleteDraft(this._handle, uri);
 	}
-	async finishDraft(token): Promise<void> {
-		return this._proxy.$finishDraft(this._handle);
+	async finishDraft(uri, token): Promise<void> {
+		return this._proxy.$finishDraft(this._handle, uri);
 	}
+	async addReaction(uri, comment: modes.Comment, reaction: modes.CommentReaction, token): Promise<void> {
+		return this._proxy.$addReaction(this._handle, uri, comment, reaction);
+	}
+	async deleteReaction(uri, comment: modes.Comment, reaction: modes.CommentReaction, token): Promise<void> {
+		return this._proxy.$deleteReaction(this._handle, uri, comment, reaction);
+	}
+

 	onDidChangeCommentThreads = null;
 }
@@ -72,18 +85,18 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 	private _documentProviders = new Map<number, IDisposable>();
 	private _workspaceProviders = new Map<number, IDisposable>();
 	private _handlers = new Map<number, string>();
-	private _firstSessionStart: boolean;
+	private _openPanelListener: IDisposable | null;

 	constructor(
 		extHostContext: IExtHostContext,
-		@IEditorService private _editorService: IEditorService,
-		@ICommentService private _commentService: ICommentService,
-		@IPanelService private _panelService: IPanelService,
-		@ITelemetryService private _telemetryService: ITelemetryService
+		@IEditorService private readonly _editorService: IEditorService,
+		@ICommentService private readonly _commentService: ICommentService,
+		@IPanelService private readonly _panelService: IPanelService,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+		@IConfigurationService private readonly _configurationService: IConfigurationService
 	) {
 		super();
 		this._disposables = [];
-		this._firstSessionStart = true;
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostComments);
 	}

@@ -97,19 +110,67 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		this._commentService.registerDataProvider(providerId, handler);
 	}

-	$registerWorkspaceCommentProvider(handle: number, extensionId: string): void {
+	/**
+	 * If the comments panel has never been opened, the constructor for it has not yet run so it has
+	 * no listeners for comment threads being set or updated. Listen for the panel opening for the
+	 * first time and send it comments then.
+	 */
+	private registerOpenPanelListener(commentsPanelAlreadyConstructed: boolean) {
+		if (!commentsPanelAlreadyConstructed && !this._openPanelListener) {
+			this._openPanelListener = this._panelService.onDidPanelOpen(e => {
+				if (e.panel.getId() === COMMENTS_PANEL_ID) {
+					keys(this._workspaceProviders).forEach(handle => {
+						this._proxy.$provideWorkspaceComments(handle).then(commentThreads => {
+							if (commentThreads) {
+								const providerId = this._handlers.get(handle);
+								this._commentService.setWorkspaceComments(providerId, commentThreads);
+							}
+
+						});
+					});
+
+					this._openPanelListener.dispose();
+					this._openPanelListener = null;
+				}
+			});
+		}
+	}
+
+	$registerWorkspaceCommentProvider(handle: number, extensionId: ExtensionIdentifier): void {
 		this._workspaceProviders.set(handle, undefined);

 		const providerId = generateUuid();
 		this._handlers.set(handle, providerId);

-		this._panelService.setPanelEnablement(COMMENTS_PANEL_ID, true);
-		if (this._firstSessionStart) {
-			this._panelService.openPanel(COMMENTS_PANEL_ID);
-			this._firstSessionStart = false;
+		const commentsPanelAlreadyConstructed = this._panelService.getPanels().some(panel => panel.id === COMMENTS_PANEL_ID);
+		Registry.as<PanelRegistry>(PanelExtensions.Panels).registerPanel(new PanelDescriptor(
+			CommentsPanel,
+			COMMENTS_PANEL_ID,
+			COMMENTS_PANEL_TITLE,
+			'commentsPanel',
+			10
+		));
+
+		const openPanel = this._configurationService.getValue<ICommentsConfiguration>('comments').openPanel;
+
+		if (openPanel === 'neverOpen') {
+			this.registerOpenPanelListener(commentsPanelAlreadyConstructed);
 		}
+
+		if (openPanel === 'openOnSessionStart') {
+			this._panelService.openPanel(COMMENTS_PANEL_ID);
+		}
+
 		this._proxy.$provideWorkspaceComments(handle).then(commentThreads => {
 			if (commentThreads) {
+				if (openPanel === 'openOnSessionStartWithComments' && commentThreads.length) {
+					if (commentThreads.length) {
+						this._panelService.openPanel(COMMENTS_PANEL_ID);
+					} else {
+						this.registerOpenPanelListener(commentsPanelAlreadyConstructed);
+					}
+				}
+
 				this._commentService.setWorkspaceComments(providerId, commentThreads);
 			}
 		});
@@ -120,7 +181,7 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 			}
 		*/
 		this._telemetryService.publicLog('comments:registerWorkspaceCommentProvider', {
-			extensionId: extensionId
+			extensionId: extensionId.value
 		});
 	}

@@ -134,8 +195,14 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 	$unregisterWorkspaceCommentProvider(handle: number): void {
 		this._workspaceProviders.delete(handle);
 		if (this._workspaceProviders.size === 0) {
-			this._panelService.setPanelEnablement(COMMENTS_PANEL_ID, false);
+			Registry.as<PanelRegistry>(PanelExtensions.Panels).deregisterPanel(COMMENTS_PANEL_ID);
+
+			if (this._openPanelListener) {
+				this._openPanelListener.dispose();
+				this._openPanelListener = null;
+			}
 		}
+
 		const handlerId = this._handlers.get(handle);
 		this._commentService.removeWorkspaceComments(handlerId);
 		this._handlers.delete(handle);
--- a/src/vs/workbench/api/electron-browser/mainThreadConfiguration.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadConfiguration.ts
@@ -6,12 +6,13 @@
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { Registry } from 'vs/platform/registry/common/platform';
-import { IConfigurationRegistry, Extensions as ConfigurationExtensions, ConfigurationScope } from 'vs/platform/configuration/common/configurationRegistry';
+import { IConfigurationRegistry, Extensions as ConfigurationExtensions, ConfigurationScope, getScopes } from 'vs/platform/configuration/common/configurationRegistry';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { IWorkspaceConfigurationService } from 'vs/workbench/services/configuration/common/configuration';
-import { MainThreadConfigurationShape, MainContext, ExtHostContext, IExtHostContext, IWorkspaceConfigurationChangeEventData } from '../node/extHost.protocol';
+import { MainThreadConfigurationShape, MainContext, ExtHostContext, IExtHostContext, IWorkspaceConfigurationChangeEventData, IConfigurationInitData } from '../node/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { ConfigurationTarget, IConfigurationChangeEvent, IConfigurationModel } from 'vs/platform/configuration/common/configuration';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';

@extHostNamedCustomer(MainContext.MainThreadConfiguration)
 export class MainThreadConfiguration implements MainThreadConfigurationShape {
@@ -21,25 +22,36 @@ export class MainThreadConfiguration implements MainThreadConfigurationShape {
 	constructor(
 		extHostContext: IExtHostContext,
 		@IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService,
-		@IWorkspaceConfigurationService private configurationService: IWorkspaceConfigurationService
+		@IWorkspaceConfigurationService private readonly configurationService: IWorkspaceConfigurationService,
+		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
 	) {
 		const proxy = extHostContext.getProxy(ExtHostContext.ExtHostConfiguration);

+		proxy.$initializeConfiguration(this._getConfigurationData());
 		this._configurationListener = configurationService.onDidChangeConfiguration(e => {
-			proxy.$acceptConfigurationChanged(configurationService.getConfigurationData(), this.toConfigurationChangeEventData(e));
+			proxy.$acceptConfigurationChanged(this._getConfigurationData(), this.toConfigurationChangeEventData(e));
 		});
 	}

+	private _getConfigurationData(): IConfigurationInitData {
+		const configurationData: IConfigurationInitData = { ...this.configurationService.getConfigurationData(), configurationScopes: {} };
+		// Send configurations scopes only in development mode.
+		if (!this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment) {
+			configurationData.configurationScopes = getScopes();
+		}
+		return configurationData;
+	}
+
 	public dispose(): void {
 		this._configurationListener.dispose();
 	}

-	$updateConfigurationOption(target: ConfigurationTarget, key: string, value: any, resourceUriComponenets: UriComponents): Thenable<void> {
+	$updateConfigurationOption(target: ConfigurationTarget, key: string, value: any, resourceUriComponenets: UriComponents): Promise<void> {
 		const resource = resourceUriComponenets ? URI.revive(resourceUriComponenets) : null;
 		return this.writeConfiguration(target, key, value, resource);
 	}

-	$removeConfigurationOption(target: ConfigurationTarget, key: string, resourceUriComponenets: UriComponents): Thenable<void> {
+	$removeConfigurationOption(target: ConfigurationTarget, key: string, resourceUriComponenets: UriComponents): Promise<void> {
 		const resource = resourceUriComponenets ? URI.revive(resourceUriComponenets) : null;
 		return this.writeConfiguration(target, key, undefined, resource);
 	}
--- a/src/vs/workbench/api/electron-browser/mainThreadConsole.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadConsole.ts
@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
+import { MainContext, MainThreadConsoleShape, IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IRemoteConsoleLog, log, parse } from 'vs/base/node/console';
+import { parseExtensionDevOptions } from 'vs/workbench/services/extensions/electron-browser/extensionHost';
+import { IWindowsService } from 'vs/platform/windows/common/windows';
+import { IBroadcastService } from 'vs/platform/broadcast/electron-browser/broadcastService';
+import { EXTENSION_LOG_BROADCAST_CHANNEL } from 'vs/platform/extensions/common/extensionHost';
+
+@extHostNamedCustomer(MainContext.MainThreadConsole)
+export class MainThreadConsole implements MainThreadConsoleShape {
+
+	private readonly _isExtensionDevHost: boolean;
+	private readonly _isExtensionDevTestFromCli: boolean;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
+		@IWindowsService private readonly _windowsService: IWindowsService,
+		@IBroadcastService private readonly _broadcastService: IBroadcastService,
+	) {
+		const devOpts = parseExtensionDevOptions(this._environmentService);
+		this._isExtensionDevHost = devOpts.isExtensionDevHost;
+		this._isExtensionDevTestFromCli = devOpts.isExtensionDevTestFromCli;
+	}
+
+	dispose(): void {
+		//
+	}
+
+	$logExtensionHostMessage(entry: IRemoteConsoleLog): void {
+		// Send to local console unless we run tests from cli
+		if (!this._isExtensionDevTestFromCli) {
+			log(entry, 'Extension Host');
+		}
+
+		// Log on main side if running tests from cli
+		if (this._isExtensionDevTestFromCli) {
+			this._windowsService.log(entry.severity, ...parse(entry).args);
+		}
+
+		// Broadcast to other windows if we are in development mode
+		else if (!this._environmentService.isBuilt || this._isExtensionDevHost) {
+			this._broadcastService.broadcast({
+				channel: EXTENSION_LOG_BROADCAST_CHANNEL,
+				payload: {
+					logEntry: entry,
+					debugId: this._environmentService.debugExtensionHost.debugId
+				}
+			});
+		}
+	}
+}
--- a/src/vs/workbench/api/electron-browser/mainThreadDebugService.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadDebugService.ts
@@ -17,7 +17,7 @@ import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostC
 import severity from 'vs/base/common/severity';
 import { AbstractDebugAdapter } from 'vs/workbench/parts/debug/node/debugAdapter';
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
-import { convertToVSCPaths, convertToDAPaths, stringToUri, uriToString } from 'vs/workbench/parts/debug/common/debugUtils';
+import { convertToVSCPaths, convertToDAPaths } from 'vs/workbench/parts/debug/common/debugUtils';

@extHostNamedCustomer(MainContext.MainThreadDebugService)
 export class MainThreadDebugService implements MainThreadDebugServiceShape, IDebugAdapterFactory {
@@ -34,7 +34,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb

 	constructor(
 		extHostContext: IExtHostContext,
-		@IDebugService private debugService: IDebugService
+		@IDebugService private readonly debugService: IDebugService
 	) {
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDebugService);
 		this._toDispose = [];
@@ -124,7 +124,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 		}
 	}

-	public $registerBreakpoints(DTOs: (ISourceMultiBreakpointDto | IFunctionBreakpointDto)[]): Thenable<void> {
+	public $registerBreakpoints(DTOs: Array<ISourceMultiBreakpointDto | IFunctionBreakpointDto>): Promise<void> {

 		for (let dto of DTOs) {
 			if (dto.type === 'sourceMulti') {
@@ -144,21 +144,20 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 				this.debugService.addFunctionBreakpoint(dto.functionName, dto.id);
 			}
 		}
-		return void 0;
+		return undefined;
 	}

-	public $unregisterBreakpoints(breakpointIds: string[], functionBreakpointIds: string[]): Thenable<void> {
+	public $unregisterBreakpoints(breakpointIds: string[], functionBreakpointIds: string[]): Promise<void> {
 		breakpointIds.forEach(id => this.debugService.removeBreakpoints(id));
 		functionBreakpointIds.forEach(id => this.debugService.removeFunctionBreakpoints(id));
-		return void 0;
+		return undefined;
 	}


-	public $registerDebugConfigurationProvider(debugType: string, hasProvide: boolean, hasResolve: boolean, hasProvideDebugAdapter: boolean, hasTracker: boolean, handle: number): Thenable<void> {
+	public $registerDebugConfigurationProvider(debugType: string, hasProvide: boolean, hasResolve: boolean, hasProvideDebugAdapter: boolean, handle: number): Promise<void> {

 		const provider = <IDebugConfigurationProvider>{
-			type: debugType,
-			hasTracker: hasTracker
+			type: debugType
 		};
 		if (hasProvide) {
 			provider.provideDebugConfigurations = (folder) => {
@@ -171,6 +170,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 			};
 		}
 		if (hasProvideDebugAdapter) {
+			console.info('DebugConfigurationProvider.debugAdapterExecutable is deprecated and will be removed soon; please use DebugAdapterDescriptorFactory.createDebugAdapterDescriptor instead.');
 			provider.debugAdapterExecutable = (folder) => {
 				return Promise.resolve(this._proxy.$legacyDebugAdapterExecutable(handle, folder));
 			};
@@ -189,7 +189,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 		}
 	}

-	public $registerDebugAdapterDescriptorFactory(debugType: string, handle: number): Thenable<void> {
+	public $registerDebugAdapterDescriptorFactory(debugType: string, handle: number): Promise<void> {

 		const provider = <IDebugAdapterDescriptorFactory>{
 			type: debugType,
@@ -229,7 +229,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 		}
 	}

-	public $startDebugging(_folderUri: uri | undefined, nameOrConfiguration: string | IConfig): Thenable<boolean> {
+	public $startDebugging(_folderUri: uri | undefined, nameOrConfiguration: string | IConfig): Promise<boolean> {
 		const folderUri = _folderUri ? uri.revive(_folderUri) : undefined;
 		const launch = this.debugService.getConfigurationManager().getLaunch(folderUri);
 		return this.debugService.startDebugging(launch, nameOrConfiguration).then(success => {
@@ -239,7 +239,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 		});
 	}

-	public $customDebugAdapterRequest(sessionId: DebugSessionUUID, request: string, args: any): Thenable<any> {
+	public $customDebugAdapterRequest(sessionId: DebugSessionUUID, request: string, args: any): Promise<any> {
 		const session = this.debugService.getModel().getSessions(true).filter(s => s.getId() === sessionId).pop();
 		if (session) {
 			return session.customRequest(request, args).then(response => {
@@ -262,8 +262,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 	}

 	public $acceptDAMessage(handle: number, message: DebugProtocol.ProtocolMessage) {
-
-		this._debugAdapters.get(handle).acceptMessage(convertToVSCPaths(message, source => uriToString(source)));
+		this._debugAdapters.get(handle).acceptMessage(convertToVSCPaths(message, false));
 	}

 	public $acceptDAError(handle: number, name: string, message: string, stack: string) {
@@ -295,7 +294,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 		return undefined;
 	}

-	private convertToDto(bps: (ReadonlyArray<IBreakpoint | IFunctionBreakpoint>)): (ISourceBreakpointDto | IFunctionBreakpointDto)[] {
+	private convertToDto(bps: (ReadonlyArray<IBreakpoint | IFunctionBreakpoint>)): Array<ISourceBreakpointDto | IFunctionBreakpointDto> {
 		return bps.map(bp => {
 			if ('name' in bp) {
 				const fbp = <IFunctionBreakpoint>bp;
@@ -351,8 +350,7 @@ class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
 	}

 	public sendMessage(message: DebugProtocol.ProtocolMessage): void {
-
-		this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, source => stringToUri(source)));
+		this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, true));
 	}

 	public stopSession(): Promise<void> {
--- a/src/vs/workbench/api/electron-browser/mainThreadDecorations.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadDecorations.ts
@@ -58,7 +58,7 @@ class DecorationRequestsQueue {
 			// reset
 			this._requests = [];
 			this._resolver = [];
-			this._timer = void 0;
+			this._timer = undefined;
 		}, 0);
 	}
 }
--- a/src/vs/workbench/api/electron-browser/mainThreadDocumentContentProviders.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadDocumentContentProviders.ts
@@ -41,7 +41,7 @@ export class MainThreadDocumentContentProviders implements MainThreadDocumentCon

 	$registerTextContentProvider(handle: number, scheme: string): void {
 		const registration = this._textModelResolverService.registerTextModelContentProvider(scheme, {
-			provideTextContent: (uri: URI): Thenable<ITextModel> => {
+			provideTextContent: (uri: URI): Promise<ITextModel> => {
 				return this._proxy.$provideTextDocumentContent(handle, uri).then(value => {
 					if (typeof value === 'string') {
 						const firstLineText = value.substr(0, 1 + value.search(/\r?\n/));
--- a/src/vs/workbench/api/electron-browser/mainThreadDocuments.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadDocuments.ts
@@ -167,20 +167,20 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {

 	// --- from extension host process

-	$trySaveDocument(uri: UriComponents): Thenable<boolean> {
+	$trySaveDocument(uri: UriComponents): Promise<boolean> {
 		return this._textFileService.save(URI.revive(uri));
 	}

-	$tryOpenDocument(_uri: UriComponents): Thenable<any> {
+	$tryOpenDocument(_uri: UriComponents): Promise<any> {
 		const uri = URI.revive(_uri);
 		if (!uri.scheme || !(uri.fsPath || uri.authority)) {
 			return Promise.reject(new Error(`Invalid uri. Scheme and authority or path must be set.`));
 		}

-		let promise: Thenable<boolean>;
+		let promise: Promise<boolean>;
 		switch (uri.scheme) {
 			case Schemas.untitled:
-				promise = this._handleUnititledScheme(uri);
+				promise = this._handleUntitledScheme(uri);
 				break;
 			case Schemas.file:
 			default:
@@ -201,11 +201,11 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
 		});
 	}

-	$tryCreateDocument(options?: { language?: string, content?: string }): Thenable<URI> {
-		return this._doCreateUntitled(void 0, options ? options.language : void 0, options ? options.content : void 0);
+	$tryCreateDocument(options?: { language?: string, content?: string }): Promise<URI> {
+		return this._doCreateUntitled(undefined, options ? options.language : undefined, options ? options.content : undefined);
 	}

-	private _handleAsResourceInput(uri: URI): Thenable<boolean> {
+	private _handleAsResourceInput(uri: URI): Promise<boolean> {
 		return this._textModelResolverService.createModelReference(uri).then(ref => {
 			this._modelReferenceCollection.add(ref);
 			const result = !!ref.object;
@@ -213,7 +213,7 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
 		});
 	}

-	private _handleUnititledScheme(uri: URI): Thenable<boolean> {
+	private _handleUntitledScheme(uri: URI): Promise<boolean> {
 		let asFileUri = uri.with({ scheme: Schemas.file });
 		return this._fileService.resolveFile(asFileUri).then(stats => {
 			// don't create a new file ontop of an existing file
@@ -223,7 +223,7 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
 		});
 	}

-	private _doCreateUntitled(resource?: URI, modeId?: string, initialValue?: string): Thenable<URI> {
+	private _doCreateUntitled(resource?: URI, modeId?: string, initialValue?: string): Promise<URI> {
 		return this._untitledEditorService.loadOrCreate({
 			resource,
 			modeId,
--- a/src/vs/workbench/api/electron-browser/mainThreadEditors.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadEditors.ts
@@ -114,7 +114,7 @@ export class MainThreadTextEditors implements MainThreadTextEditorsShape {

 	// --- from extension host process

-	$tryShowTextDocument(resource: UriComponents, options: ITextDocumentShowOptions): Thenable<string> {
+	$tryShowTextDocument(resource: UriComponents, options: ITextDocumentShowOptions): Promise<string> {
 		const uri = URI.revive(resource);

 		const editorOptions: ITextEditorOptions = {
@@ -136,7 +136,7 @@ export class MainThreadTextEditors implements MainThreadTextEditorsShape {
 		});
 	}

-	$tryShowEditor(id: string, position?: EditorViewColumn): Thenable<void> {
+	$tryShowEditor(id: string, position?: EditorViewColumn): Promise<void> {
 		let mainThreadEditor = this._documentsAndEditors.getEditor(id);
 		if (mainThreadEditor) {
 			let model = mainThreadEditor.getModel();
@@ -148,7 +148,7 @@ export class MainThreadTextEditors implements MainThreadTextEditorsShape {
 		return undefined;
 	}

-	$tryHideEditor(id: string): Thenable<void> {
+	$tryHideEditor(id: string): Promise<void> {
 		let mainThreadEditor = this._documentsAndEditors.getEditor(id);
 		if (mainThreadEditor) {
 			let editors = this._editorService.visibleControls;
@@ -161,33 +161,33 @@ export class MainThreadTextEditors implements MainThreadTextEditorsShape {
 		return undefined;
 	}

-	$trySetSelections(id: string, selections: ISelection[]): Thenable<void> {
+	$trySetSelections(id: string, selections: ISelection[]): Promise<void> {
 		if (!this._documentsAndEditors.getEditor(id)) {
 			return Promise.reject(disposed(`TextEditor(${id})`));
 		}
 		this._documentsAndEditors.getEditor(id).setSelections(selections);
-		return Promise.resolve(null);
+		return Promise.resolve(undefined);
 	}

-	$trySetDecorations(id: string, key: string, ranges: IDecorationOptions[]): Thenable<void> {
+	$trySetDecorations(id: string, key: string, ranges: IDecorationOptions[]): Promise<void> {
 		key = `${this._instanceId}-${key}`;
 		if (!this._documentsAndEditors.getEditor(id)) {
 			return Promise.reject(disposed(`TextEditor(${id})`));
 		}
 		this._documentsAndEditors.getEditor(id).setDecorations(key, ranges);
-		return Promise.resolve(null);
+		return Promise.resolve(undefined);
 	}

-	$trySetDecorationsFast(id: string, key: string, ranges: number[]): Thenable<void> {
+	$trySetDecorationsFast(id: string, key: string, ranges: number[]): Promise<void> {
 		key = `${this._instanceId}-${key}`;
 		if (!this._documentsAndEditors.getEditor(id)) {
 			return Promise.reject(disposed(`TextEditor(${id})`));
 		}
 		this._documentsAndEditors.getEditor(id).setDecorationsFast(key, ranges);
-		return Promise.resolve(null);
+		return Promise.resolve(undefined);
 	}

-	$tryRevealRange(id: string, range: IRange, revealType: TextEditorRevealType): Thenable<void> {
+	$tryRevealRange(id: string, range: IRange, revealType: TextEditorRevealType): Promise<void> {
 		if (!this._documentsAndEditors.getEditor(id)) {
 			return Promise.reject(disposed(`TextEditor(${id})`));
 		}
@@ -195,27 +195,27 @@ export class MainThreadTextEditors implements MainThreadTextEditorsShape {
 		return undefined;
 	}

-	$trySetOptions(id: string, options: ITextEditorConfigurationUpdate): Thenable<void> {
+	$trySetOptions(id: string, options: ITextEditorConfigurationUpdate): Promise<void> {
 		if (!this._documentsAndEditors.getEditor(id)) {
 			return Promise.reject(disposed(`TextEditor(${id})`));
 		}
 		this._documentsAndEditors.getEditor(id).setConfiguration(options);
-		return Promise.resolve(null);
+		return Promise.resolve(undefined);
 	}

-	$tryApplyEdits(id: string, modelVersionId: number, edits: ISingleEditOperation[], opts: IApplyEditsOptions): Thenable<boolean> {
+	$tryApplyEdits(id: string, modelVersionId: number, edits: ISingleEditOperation[], opts: IApplyEditsOptions): Promise<boolean> {
 		if (!this._documentsAndEditors.getEditor(id)) {
 			return Promise.reject(disposed(`TextEditor(${id})`));
 		}
 		return Promise.resolve(this._documentsAndEditors.getEditor(id).applyEdits(modelVersionId, edits, opts));
 	}

-	$tryApplyWorkspaceEdit(dto: WorkspaceEditDto): Thenable<boolean> {
+	$tryApplyWorkspaceEdit(dto: WorkspaceEditDto): Promise<boolean> {
 		const { edits } = reviveWorkspaceEditDto(dto);
 		return this._bulkEditService.apply({ edits }, undefined).then(() => true, err => false);
 	}

-	$tryInsertSnippet(id: string, template: string, ranges: IRange[], opts: IUndoStopOptions): Thenable<boolean> {
+	$tryInsertSnippet(id: string, template: string, ranges: IRange[], opts: IUndoStopOptions): Promise<boolean> {
 		if (!this._documentsAndEditors.getEditor(id)) {
 			return Promise.reject(disposed(`TextEditor(${id})`));
 		}
@@ -234,7 +234,7 @@ export class MainThreadTextEditors implements MainThreadTextEditorsShape {
 		this._codeEditorService.removeDecorationType(key);
 	}

-	$getDiffInformation(id: string): Thenable<ILineChange[]> {
+	$getDiffInformation(id: string): Promise<ILineChange[]> {
 		const editor = this._documentsAndEditors.getEditor(id);

 		if (!editor) {
@@ -272,20 +272,20 @@ CommandsRegistry.registerCommand('_workbench.open', function (accessor: Services

 	if (options || typeof position === 'number') {
 		// use editor options or editor view column as a hint to use the editor service for opening
-		return editorService.openEditor({ resource, options, label }, viewColumnToEditorGroup(editorGroupService, position)).then(_ => void 0);
+		return editorService.openEditor({ resource, options, label }, viewColumnToEditorGroup(editorGroupService, position)).then(_ => undefined);
 	}

 	if (resource && resource.scheme === 'command') {
 		// do not allow to execute commands from here
-		return Promise.resolve(void 0);
+		return Promise.resolve(undefined);
 	}

 	if (resource && (resource.scheme === product.urlProtocol || /^vscode/.test(resource.scheme))) {
-		return urlService.open(resource).then(_ => void 0);
+		return urlService.open(resource).then(_ => undefined);
 	}

 	// finally, delegate to opener service
-	return openerService.open(resource).then(_ => void 0);
+	return openerService.open(resource).then(_ => undefined);
 });


@@ -305,5 +305,5 @@ CommandsRegistry.registerCommand('_workbench.diff', function (accessor: Services
 		label = localize('diffLeftRightLabel', "{0} ⟷ {1}", leftResource.toString(true), rightResource.toString(true));
 	}

-	return editorService.openEditor({ leftResource, rightResource, label, description, options }, viewColumnToEditorGroup(editorGroupService, position)).then(() => void 0);
+	return editorService.openEditor({ leftResource, rightResource, label, description, options }, viewColumnToEditorGroup(editorGroupService, position)).then(() => undefined);
 });
--- a/src/vs/workbench/api/electron-browser/mainThreadExtensionService.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadExtensionService.ts
@@ -9,6 +9,7 @@ import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostC
 import { IExtHostContext, MainContext, MainThreadExtensionServiceShape } from 'vs/workbench/api/node/extHost.protocol';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 import { ExtensionService } from 'vs/workbench/services/extensions/electron-browser/extensionService';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

@extHostNamedCustomer(MainContext.MainThreadExtensionService)
 export class MainThreadExtensionService implements MainThreadExtensionServiceShape {
@@ -30,10 +31,13 @@ export class MainThreadExtensionService implements MainThreadExtensionServiceSha
 	$localShowMessage(severity: Severity, msg: string): void {
 		this._extensionService._logOrShowMessage(severity, msg);
 	}
-	$onExtensionActivated(extensionId: string, startup: boolean, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationEvent: string): void {
-		this._extensionService._onExtensionActivated(extensionId, startup, codeLoadingTime, activateCallTime, activateResolvedTime, activationEvent);
+	$onWillActivateExtension(extensionId: ExtensionIdentifier): void {
+		this._extensionService._onWillActivateExtension(extensionId);
 	}
-	$onExtensionRuntimeError(extensionId: string, data: SerializedError): void {
+	$onDidActivateExtension(extensionId: ExtensionIdentifier, startup: boolean, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationEvent: string): void {
+		this._extensionService._onDidActivateExtension(extensionId, startup, codeLoadingTime, activateCallTime, activateResolvedTime, activationEvent);
+	}
+	$onExtensionRuntimeError(extensionId: ExtensionIdentifier, data: SerializedError): void {
 		const error = new Error();
 		error.name = data.name;
 		error.message = data.message;
@@ -42,9 +46,9 @@ export class MainThreadExtensionService implements MainThreadExtensionServiceSha
 		console.error(`[${extensionId}]${error.message}`);
 		console.error(error.stack);
 	}
-	$onExtensionActivationFailed(extensionId: string): void {
+	$onExtensionActivationFailed(extensionId: ExtensionIdentifier): void {
 	}
-	$addMessage(extensionId: string, severity: Severity, message: string): void {
+	$addMessage(extensionId: ExtensionIdentifier, severity: Severity, message: string): void {
 		this._extensionService._addMessage(extensionId, severity, message);
 	}
 }
--- a/src/vs/workbench/api/electron-browser/mainThreadFileSystem.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadFileSystem.ts
@@ -6,10 +6,10 @@
 import { Emitter, Event } from 'vs/base/common/event';
 import { IDisposable, dispose, toDisposable } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
-import { FileWriteOptions, FileSystemProviderCapabilities, IFileChange, IFileService, IFileSystemProvider, IStat, IWatchOptions, FileType, FileOverwriteOptions, FileDeleteOptions } from 'vs/platform/files/common/files';
+import { FileWriteOptions, FileSystemProviderCapabilities, IFileChange, IFileService, IFileSystemProvider, IStat, IWatchOptions, FileType, FileOverwriteOptions, FileDeleteOptions, FileOpenOptions } from 'vs/platform/files/common/files';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { ExtHostContext, ExtHostFileSystemShape, IExtHostContext, IFileChangeDto, MainContext, MainThreadFileSystemShape } from '../node/extHost.protocol';
-import { LabelRules, ILabelService } from 'vs/platform/label/common/label';
+import { ResourceLabelFormatter, ILabelService } from 'vs/platform/label/common/label';

@extHostNamedCustomer(MainContext.MainThreadFileSystem)
 export class MainThreadFileSystem implements MainThreadFileSystemShape {
@@ -39,8 +39,8 @@ export class MainThreadFileSystem implements MainThreadFileSystemShape {
 		this._fileProvider.delete(handle);
 	}

-	$setUriFormatter(selector: string, formatter: LabelRules): void {
-		this._labelService.registerFormatter(selector, formatter);
+	$setUriFormatter(formatter: ResourceLabelFormatter): void {
+		this._labelService.registerFormatter(formatter);
 	}

 	$onFileSystemChange(handle: number, changes: IFileChangeDto[]): void {
@@ -96,53 +96,56 @@ class RemoteFileSystemProvider implements IFileSystemProvider {
 		return Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
 	}

-	stat(resource: URI): Thenable<IStat> {
+	stat(resource: URI): Promise<IStat> {
 		return this._proxy.$stat(this._handle, resource).then(undefined, err => {
 			throw err;
 		});
 	}

-	readFile(resource: URI): Thenable<Uint8Array> {
+	readFile(resource: URI): Promise<Uint8Array> {
 		return this._proxy.$readFile(this._handle, resource);
 	}

-	writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Thenable<void> {
+	writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
 		return this._proxy.$writeFile(this._handle, resource, RemoteFileSystemProvider._asBuffer(content), opts);
 	}

-	delete(resource: URI, opts: FileDeleteOptions): Thenable<void> {
+	delete(resource: URI, opts: FileDeleteOptions): Promise<void> {
 		return this._proxy.$delete(this._handle, resource, opts);
 	}

-	mkdir(resource: URI): Thenable<void> {
+	mkdir(resource: URI): Promise<void> {
 		return this._proxy.$mkdir(this._handle, resource);
 	}

-	readdir(resource: URI): Thenable<[string, FileType][]> {
+	readdir(resource: URI): Promise<[string, FileType][]> {
 		return this._proxy.$readdir(this._handle, resource);
 	}

-	rename(resource: URI, target: URI, opts: FileOverwriteOptions): Thenable<void> {
+	rename(resource: URI, target: URI, opts: FileOverwriteOptions): Promise<void> {
 		return this._proxy.$rename(this._handle, resource, target, opts);
 	}

-	copy(resource: URI, target: URI, opts: FileOverwriteOptions): Thenable<void> {
+	copy(resource: URI, target: URI, opts: FileOverwriteOptions): Promise<void> {
 		return this._proxy.$copy(this._handle, resource, target, opts);
 	}

-	open(resource: URI): Thenable<number> {
-		return this._proxy.$open(this._handle, resource);
+	open(resource: URI, opts: FileOpenOptions): Promise<number> {
+		return this._proxy.$open(this._handle, resource, opts);
 	}

-	close(fd: number): Thenable<void> {
+	close(fd: number): Promise<void> {
 		return this._proxy.$close(this._handle, fd);
 	}

-	read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Thenable<number> {
-		return this._proxy.$read(this._handle, fd, pos, RemoteFileSystemProvider._asBuffer(data), offset, length);
+	read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
+		return this._proxy.$read(this._handle, fd, pos, length).then(readData => {
+			data.set(readData, offset);
+			return readData.byteLength;
+		});
 	}

-	write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Thenable<number> {
-		return this._proxy.$write(this._handle, fd, pos, RemoteFileSystemProvider._asBuffer(data), offset, length);
+	write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
+		return this._proxy.$write(this._handle, fd, pos, Buffer.from(data, offset, length));
 	}
 }
--- a/src/vs/workbench/api/electron-browser/mainThreadHeapService.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadHeapService.ts
@@ -23,7 +23,7 @@ export interface IHeapService {
 	 * Track gc-collection for all new objects that
 	 * have the $ident-value set.
 	 */
-	trackRecursive<T>(obj: T | Thenable<T>): Thenable<T>;
+	trackRecursive<T>(obj: T | Promise<T>): Promise<T>;
 }

 export class HeapService implements IHeapService {
@@ -45,7 +45,7 @@ export class HeapService implements IHeapService {
 		clearInterval(this._consumeHandle);
 	}

-	trackRecursive<T>(obj: T | Thenable<T>): Thenable<T> {
+	trackRecursive<T>(obj: T | Promise<T>): Promise<T> {
 		if (isThenable(obj)) {
 			return obj.then(result => this.trackRecursive(result));
 		} else {
@@ -61,7 +61,7 @@ export class HeapService implements IHeapService {

 		return import('gc-signals').then(({ GCSignal, consumeSignals }) => {

-			if (this._consumeHandle === void 0) {
+			if (this._consumeHandle === undefined) {
 				// ensure that there is one consumer of signals
 				this._consumeHandle = setInterval(() => {
 					const ids = consumeSignals();
--- a/src/vs/workbench/api/electron-browser/mainThreadLanguageFeatures.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadLanguageFeatures.ts
@@ -69,17 +69,17 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 		}
 	}

-	private static _reviveDefinitionLinkDto(data: DefinitionLinkDto): modes.DefinitionLink;
-	private static _reviveDefinitionLinkDto(data: DefinitionLinkDto[]): modes.DefinitionLink[];
-	private static _reviveDefinitionLinkDto(data: DefinitionLinkDto | DefinitionLinkDto[]): modes.DefinitionLink | modes.DefinitionLink[] {
+	private static _reviveLocationLinkDto(data: DefinitionLinkDto): modes.LocationLink;
+	private static _reviveLocationLinkDto(data: DefinitionLinkDto[]): modes.LocationLink[];
+	private static _reviveLocationLinkDto(data: DefinitionLinkDto | DefinitionLinkDto[]): modes.LocationLink | modes.LocationLink[] {
 		if (!data) {
-			return <modes.DefinitionLink>data;
+			return <modes.LocationLink>data;
 		} else if (Array.isArray(data)) {
-			data.forEach(l => MainThreadLanguageFeatures._reviveDefinitionLinkDto(l));
-			return <modes.DefinitionLink[]>data;
+			data.forEach(l => MainThreadLanguageFeatures._reviveLocationLinkDto(l));
+			return <modes.LocationLink[]>data;
 		} else {
 			data.uri = URI.revive(data.uri);
-			return <modes.DefinitionLink>data;
+			return <modes.LocationLink>data;
 		}
 	}

@@ -108,10 +108,10 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 	// --- outline

-	$registerOutlineSupport(handle: number, selector: ISerializedDocumentFilter[], displayName: string): void {
+	$registerDocumentSymbolProvider(handle: number, selector: ISerializedDocumentFilter[], displayName: string): void {
 		this._registrations[handle] = modes.DocumentSymbolProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.DocumentSymbolProvider>{
 			displayName,
-			provideDocumentSymbols: (model: ITextModel, token: CancellationToken): Thenable<modes.DocumentSymbol[]> => {
+			provideDocumentSymbols: (model: ITextModel, token: CancellationToken): Promise<modes.DocumentSymbol[]> => {
 				return this._proxy.$provideDocumentSymbols(handle, model.uri, token);
 			}
 		});
@@ -122,10 +122,10 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 	$registerCodeLensSupport(handle: number, selector: ISerializedDocumentFilter[], eventHandle: number): void {

 		const provider = <modes.CodeLensProvider>{
-			provideCodeLenses: (model: ITextModel, token: CancellationToken): modes.ICodeLensSymbol[] | Thenable<modes.ICodeLensSymbol[]> => {
+			provideCodeLenses: (model: ITextModel, token: CancellationToken): modes.ICodeLensSymbol[] | Promise<modes.ICodeLensSymbol[]> => {
 				return this._heapService.trackRecursive(this._proxy.$provideCodeLenses(handle, model.uri, token));
 			},
-			resolveCodeLens: (model: ITextModel, codeLens: modes.ICodeLensSymbol, token: CancellationToken): modes.ICodeLensSymbol | Thenable<modes.ICodeLensSymbol> => {
+			resolveCodeLens: (model: ITextModel, codeLens: modes.ICodeLensSymbol, token: CancellationToken): modes.ICodeLensSymbol | Promise<modes.ICodeLensSymbol> => {
 				return this._heapService.trackRecursive(this._proxy.$resolveCodeLens(handle, model.uri, codeLens, token));
 			}
 		};
@@ -150,8 +150,8 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 	$registerDefinitionSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
 		this._registrations[handle] = modes.DefinitionProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.DefinitionProvider>{
-			provideDefinition: (model, position, token): Thenable<modes.DefinitionLink[]> => {
-				return this._proxy.$provideDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveDefinitionLinkDto);
+			provideDefinition: (model, position, token): Promise<modes.LocationLink[]> => {
+				return this._proxy.$provideDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
 			}
 		});
 	}
@@ -159,23 +159,23 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 	$registerDeclarationSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
 		this._registrations[handle] = modes.DeclarationProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.DeclarationProvider>{
 			provideDeclaration: (model, position, token) => {
-				return this._proxy.$provideDeclaration(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveDefinitionLinkDto);
+				return this._proxy.$provideDeclaration(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
 			}
 		});
 	}

 	$registerImplementationSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
 		this._registrations[handle] = modes.ImplementationProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.ImplementationProvider>{
-			provideImplementation: (model, position, token): Thenable<modes.Definition> => {
-				return this._proxy.$provideImplementation(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveDefinitionLinkDto);
+			provideImplementation: (model, position, token): Promise<modes.LocationLink[]> => {
+				return this._proxy.$provideImplementation(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
 			}
 		});
 	}

 	$registerTypeDefinitionSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
 		this._registrations[handle] = modes.TypeDefinitionProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.TypeDefinitionProvider>{
-			provideTypeDefinition: (model, position, token): Thenable<modes.Definition> => {
-				return this._proxy.$provideTypeDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveDefinitionLinkDto);
+			provideTypeDefinition: (model, position, token): Promise<modes.LocationLink[]> => {
+				return this._proxy.$provideTypeDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
 			}
 		});
 	}
@@ -184,7 +184,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 	$registerHoverProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
 		this._registrations[handle] = modes.HoverProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.HoverProvider>{
-			provideHover: (model: ITextModel, position: EditorPosition, token: CancellationToken): Thenable<modes.Hover> => {
+			provideHover: (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.Hover> => {
 				return this._proxy.$provideHover(handle, model.uri, position, token);
 			}
 		});
@@ -194,7 +194,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 	$registerDocumentHighlightProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
 		this._registrations[handle] = modes.DocumentHighlightProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.DocumentHighlightProvider>{
-			provideDocumentHighlights: (model: ITextModel, position: EditorPosition, token: CancellationToken): Thenable<modes.DocumentHighlight[]> => {
+			provideDocumentHighlights: (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.DocumentHighlight[]> => {
 				return this._proxy.$provideDocumentHighlights(handle, model.uri, position, token);
 			}
 		});
@@ -204,7 +204,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 	$registerReferenceSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
 		this._registrations[handle] = modes.ReferenceProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.ReferenceProvider>{
-			provideReferences: (model: ITextModel, position: EditorPosition, context: modes.ReferenceContext, token: CancellationToken): Thenable<modes.Location[]> => {
+			provideReferences: (model: ITextModel, position: EditorPosition, context: modes.ReferenceContext, token: CancellationToken): Promise<modes.Location[]> => {
 				return this._proxy.$provideReferences(handle, model.uri, position, context, token).then(MainThreadLanguageFeatures._reviveLocationDto);
 			}
 		});
@@ -214,7 +214,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 	$registerQuickFixSupport(handle: number, selector: ISerializedDocumentFilter[], providedCodeActionKinds?: string[]): void {
 		this._registrations[handle] = modes.CodeActionProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.CodeActionProvider>{
-			provideCodeActions: (model: ITextModel, rangeOrSelection: EditorRange | Selection, context: modes.CodeActionContext, token: CancellationToken): Thenable<modes.CodeAction[]> => {
+			provideCodeActions: (model: ITextModel, rangeOrSelection: EditorRange | Selection, context: modes.CodeActionContext, token: CancellationToken): Promise<modes.CodeAction[]> => {
 				return this._heapService.trackRecursive(this._proxy.$provideCodeActions(handle, model.uri, rangeOrSelection, context, token)).then(MainThreadLanguageFeatures._reviveCodeActionDto);
 			},
 			providedCodeActionKinds
@@ -223,17 +223,19 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 	// --- formatting

-	$registerDocumentFormattingSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
+	$registerDocumentFormattingSupport(handle: number, selector: ISerializedDocumentFilter[], displayName: string): void {
 		this._registrations[handle] = modes.DocumentFormattingEditProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.DocumentFormattingEditProvider>{
-			provideDocumentFormattingEdits: (model: ITextModel, options: modes.FormattingOptions, token: CancellationToken): Thenable<ISingleEditOperation[]> => {
+			displayName,
+			provideDocumentFormattingEdits: (model: ITextModel, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[]> => {
 				return this._proxy.$provideDocumentFormattingEdits(handle, model.uri, options, token);
 			}
 		});
 	}

-	$registerRangeFormattingSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
+	$registerRangeFormattingSupport(handle: number, selector: ISerializedDocumentFilter[], displayName: string): void {
 		this._registrations[handle] = modes.DocumentRangeFormattingEditProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.DocumentRangeFormattingEditProvider>{
-			provideDocumentRangeFormattingEdits: (model: ITextModel, range: EditorRange, options: modes.FormattingOptions, token: CancellationToken): Thenable<ISingleEditOperation[]> => {
+			displayName,
+			provideDocumentRangeFormattingEdits: (model: ITextModel, range: EditorRange, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[]> => {
 				return this._proxy.$provideDocumentRangeFormattingEdits(handle, model.uri, range, options, token);
 			}
 		});
@@ -244,7 +246,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 			autoFormatTriggerCharacters,

-			provideOnTypeFormattingEdits: (model: ITextModel, position: EditorPosition, ch: string, options: modes.FormattingOptions, token: CancellationToken): Thenable<ISingleEditOperation[]> => {
+			provideOnTypeFormattingEdits: (model: ITextModel, position: EditorPosition, ch: string, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[]> => {
 				return this._proxy.$provideOnTypeFormattingEdits(handle, model.uri, position, ch, options, token);
 			}
 		});
@@ -255,7 +257,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 	$registerNavigateTypeSupport(handle: number): void {
 		let lastResultId: number;
 		this._registrations[handle] = search.WorkspaceSymbolProviderRegistry.register(<search.IWorkspaceSymbolProvider>{
-			provideWorkspaceSymbols: (search: string, token: CancellationToken): Thenable<search.IWorkspaceSymbol[]> => {
+			provideWorkspaceSymbols: (search: string, token: CancellationToken): Promise<search.IWorkspaceSymbol[]> => {
 				return this._proxy.$provideWorkspaceSymbols(handle, search, token).then(result => {
 					if (lastResultId !== undefined) {
 						this._proxy.$releaseWorkspaceSymbols(handle, lastResultId);
@@ -264,7 +266,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 					return MainThreadLanguageFeatures._reviveWorkspaceSymbolDto(result.symbols);
 				});
 			},
-			resolveWorkspaceSymbol: (item: search.IWorkspaceSymbol, token: CancellationToken): Thenable<search.IWorkspaceSymbol> => {
+			resolveWorkspaceSymbol: (item: search.IWorkspaceSymbol, token: CancellationToken): Promise<search.IWorkspaceSymbol> => {
 				return this._proxy.$resolveWorkspaceSymbol(handle, item, token).then(i => MainThreadLanguageFeatures._reviveWorkspaceSymbolDto(i));
 			}
 		});
@@ -275,11 +277,11 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 	$registerRenameSupport(handle: number, selector: ISerializedDocumentFilter[], supportResolveLocation: boolean): void {

 		this._registrations[handle] = modes.RenameProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.RenameProvider>{
-			provideRenameEdits: (model: ITextModel, position: EditorPosition, newName: string, token: CancellationToken): Thenable<modes.WorkspaceEdit> => {
+			provideRenameEdits: (model: ITextModel, position: EditorPosition, newName: string, token: CancellationToken): Promise<modes.WorkspaceEdit> => {
 				return this._proxy.$provideRenameEdits(handle, model.uri, position, newName, token).then(reviveWorkspaceEditDto);
 			},
 			resolveRenameLocation: supportResolveLocation
-				? (model: ITextModel, position: EditorPosition, token: CancellationToken): Thenable<modes.RenameLocation> => this._proxy.$resolveRenameLocation(handle, model.uri, position, token)
+				? (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.RenameLocation> => this._proxy.$resolveRenameLocation(handle, model.uri, position, token)
 				: undefined
 		});
 	}
@@ -289,7 +291,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 	$registerSuggestSupport(handle: number, selector: ISerializedDocumentFilter[], triggerCharacters: string[], supportsResolveDetails: boolean): void {
 		this._registrations[handle] = modes.CompletionProviderRegistry.register(typeConverters.LanguageSelector.from(selector), <modes.CompletionItemProvider>{
 			triggerCharacters,
-			provideCompletionItems: (model: ITextModel, position: EditorPosition, context: modes.CompletionContext, token: CancellationToken): Thenable<modes.CompletionList> => {
+			provideCompletionItems: (model: ITextModel, position: EditorPosition, context: modes.CompletionContext, token: CancellationToken): Promise<modes.CompletionList> => {
 				return this._proxy.$provideCompletionItems(handle, model.uri, position, context, token).then(result => {
 					if (!result) {
 						return result;
@@ -315,7 +317,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 			signatureHelpTriggerCharacters: metadata.triggerCharacters,
 			signatureHelpRetriggerCharacters: metadata.retriggerCharacters,

-			provideSignatureHelp: (model: ITextModel, position: EditorPosition, token: CancellationToken, context: modes.SignatureHelpContext): Thenable<modes.SignatureHelp> => {
+			provideSignatureHelp: (model: ITextModel, position: EditorPosition, token: CancellationToken, context: modes.SignatureHelpContext): Promise<modes.SignatureHelp> => {
 				return this._proxy.$provideSignatureHelp(handle, model.uri, position, context, token);
 			}
 		});
--- a/src/vs/workbench/api/electron-browser/mainThreadLanguages.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadLanguages.ts
@@ -23,11 +23,11 @@ export class MainThreadLanguages implements MainThreadLanguagesShape {
 		// nothing
 	}

-	$getLanguages(): Thenable<string[]> {
+	$getLanguages(): Promise<string[]> {
 		return Promise.resolve(this._modeService.getRegisteredModes());
 	}

-	$changeLanguage(resource: UriComponents, languageId: string): Thenable<void> {
+	$changeLanguage(resource: UriComponents, languageId: string): Promise<void> {
 		const uri = URI.revive(resource);
 		let model = this._modelService.getModel(uri);
 		if (!model) {
--- a/src/vs/workbench/api/electron-browser/mainThreadMessageService.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadMessageService.ts
@@ -11,9 +11,10 @@ import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostC
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
 import { INotificationService } from 'vs/platform/notification/common/notification';
-import { once } from 'vs/base/common/event';
+import { Event } from 'vs/base/common/event';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { dispose } from 'vs/base/common/lifecycle';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

@extHostNamedCustomer(MainContext.MainThreadMessageService)
 export class MainThreadMessageService implements MainThreadMessageServiceShape {
@@ -31,7 +32,7 @@ export class MainThreadMessageService implements MainThreadMessageServiceShape {
 		//
 	}

-	$showMessage(severity: Severity, message: string, options: MainThreadMessageOptions, commands: { title: string; isCloseAffordance: boolean; handle: number; }[]): Thenable<number> {
+	$showMessage(severity: Severity, message: string, options: MainThreadMessageOptions, commands: { title: string; isCloseAffordance: boolean; handle: number; }[]): Promise<number> {
 		if (options.modal) {
 			return this._showModalMessage(severity, message, commands);
 		} else {
@@ -39,7 +40,7 @@ export class MainThreadMessageService implements MainThreadMessageServiceShape {
 		}
 	}

-	private _showMessage(severity: Severity, message: string, commands: { title: string; isCloseAffordance: boolean; handle: number; }[], extension: IExtensionDescription): Thenable<number> {
+	private _showMessage(severity: Severity, message: string, commands: { title: string; isCloseAffordance: boolean; handle: number; }[], extension: IExtensionDescription): Promise<number> {

 		return new Promise<number>(resolve => {

@@ -55,9 +56,9 @@ export class MainThreadMessageService implements MainThreadMessageServiceShape {
 			}

 			class ManageExtensionAction extends Action {
-				constructor(id: string, label: string, commandService: ICommandService) {
-					super(id, label, undefined, true, () => {
-						return commandService.executeCommand('_extensions.manage', id);
+				constructor(id: ExtensionIdentifier, label: string, commandService: ICommandService) {
+					super(id.value, label, undefined, true, () => {
+						return commandService.executeCommand('_extensions.manage', id.value);
 					});
 				}
 			}
@@ -77,7 +78,7 @@ export class MainThreadMessageService implements MainThreadMessageServiceShape {

 			const secondaryActions: IAction[] = [];
 			if (extension && !extension.isUnderDevelopment) {
-				secondaryActions.push(new ManageExtensionAction(extension.id, nls.localize('manageExtension', "Manage Extension"), this._commandService));
+				secondaryActions.push(new ManageExtensionAction(extension.identifier, nls.localize('manageExtension', "Manage Extension"), this._commandService));
 			}

 			const messageHandle = this._notificationService.notify({
@@ -89,15 +90,15 @@ export class MainThreadMessageService implements MainThreadMessageServiceShape {

 			// if promise has not been resolved yet, now is the time to ensure a return value
 			// otherwise if already resolved it means the user clicked one of the buttons
-			once(messageHandle.onDidClose)(() => {
+			Event.once(messageHandle.onDidClose)(() => {
 				dispose(...primaryActions, ...secondaryActions);
 				resolve(undefined);
 			});
 		});
 	}

-	private _showModalMessage(severity: Severity, message: string, commands: { title: string; isCloseAffordance: boolean; handle: number; }[]): Thenable<number> {
-		let cancelId: number | undefined = void 0;
+	private _showModalMessage(severity: Severity, message: string, commands: { title: string; isCloseAffordance: boolean; handle: number; }[]): Promise<number> {
+		let cancelId: number | undefined = undefined;

 		const buttons = commands.map((command, index) => {
 			if (command.isCloseAffordance === true) {
@@ -107,7 +108,7 @@ export class MainThreadMessageService implements MainThreadMessageServiceShape {
 			return command.title;
 		});

-		if (cancelId === void 0) {
+		if (cancelId === undefined) {
 			if (buttons.length > 0) {
 				buttons.push(nls.localize('cancel', "Cancel"));
 			} else {
--- a/src/vs/workbench/api/electron-browser/mainThreadOutputService.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadOutputService.ts
@@ -11,7 +11,7 @@ import { MainThreadOutputServiceShape, MainContext, IExtHostContext, ExtHostOutp
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { UriComponents, URI } from 'vs/base/common/uri';
 import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
-import { anyEvent } from 'vs/base/common/event';
+import { Event } from 'vs/base/common/event';

@extHostNamedCustomer(MainContext.MainThreadOutputService)
 export class MainThreadOutputService extends Disposable implements MainThreadOutputServiceShape {
@@ -41,18 +41,18 @@ export class MainThreadOutputService extends Disposable implements MainThreadOut
 			const visibleChannel: IOutputChannel = panel && panel.getId() === OUTPUT_PANEL_ID ? this._outputService.getActiveChannel() : null;
 			this._proxy.$setVisibleChannel(visibleChannel ? visibleChannel.id : null);
 		};
-		this._register(anyEvent<any>(this._outputService.onActiveOutputChannel, this._panelService.onDidPanelOpen, this._panelService.onDidPanelClose)(() => setVisibleChannel()));
+		this._register(Event.any<any>(this._outputService.onActiveOutputChannel, this._panelService.onDidPanelOpen, this._panelService.onDidPanelClose)(() => setVisibleChannel()));
 		setVisibleChannel();
 	}

-	public $register(label: string, log: boolean, file?: UriComponents): Thenable<string> {
+	public $register(label: string, log: boolean, file?: UriComponents): Promise<string> {
 		const id = 'extension-output-#' + (MainThreadOutputService._idPool++);
 		Registry.as<IOutputChannelRegistry>(Extensions.OutputChannels).registerChannel({ id, label, file: file ? URI.revive(file) : null, log });
 		this._register(toDisposable(() => this.$dispose(id)));
 		return Promise.resolve(id);
 	}

-	public $append(channelId: string, value: string): Thenable<void> {
+	public $append(channelId: string, value: string): Promise<void> {
 		const channel = this._getChannel(channelId);
 		if (channel) {
 			channel.append(value);
@@ -60,7 +60,7 @@ export class MainThreadOutputService extends Disposable implements MainThreadOut
 		return undefined;
 	}

-	public $update(channelId: string): Thenable<void> {
+	public $update(channelId: string): Promise<void> {
 		const channel = this._getChannel(channelId);
 		if (channel) {
 			channel.update();
@@ -68,7 +68,7 @@ export class MainThreadOutputService extends Disposable implements MainThreadOut
 		return undefined;
 	}

-	public $clear(channelId: string, till: number): Thenable<void> {
+	public $clear(channelId: string, till: number): Promise<void> {
 		const channel = this._getChannel(channelId);
 		if (channel) {
 			channel.clear(till);
@@ -76,7 +76,7 @@ export class MainThreadOutputService extends Disposable implements MainThreadOut
 		return undefined;
 	}

-	public $reveal(channelId: string, preserveFocus: boolean): Thenable<void> {
+	public $reveal(channelId: string, preserveFocus: boolean): Promise<void> {
 		const channel = this._getChannel(channelId);
 		if (channel) {
 			this._outputService.showChannel(channel.id, preserveFocus);
@@ -84,7 +84,7 @@ export class MainThreadOutputService extends Disposable implements MainThreadOut
 		return undefined;
 	}

-	public $close(channelId: string): Thenable<void> {
+	public $close(channelId: string): Promise<void> {
 		const panel = this._panelService.getActivePanel();
 		if (panel && panel.getId() === OUTPUT_PANEL_ID && channelId === this._outputService.getActiveChannel().id) {
 			this._partService.setPanelHidden(true);
@@ -93,7 +93,7 @@ export class MainThreadOutputService extends Disposable implements MainThreadOut
 		return undefined;
 	}

-	public $dispose(channelId: string): Thenable<void> {
+	public $dispose(channelId: string): Promise<void> {
 		const channel = this._getChannel(channelId);
 		if (channel) {
 			channel.dispose();
--- a/src/vs/workbench/api/electron-browser/mainThreadProgress.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadProgress.ts
@@ -11,7 +11,7 @@ import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostC
 export class MainThreadProgress implements MainThreadProgressShape {

 	private _progressService: IProgressService2;
-	private _progress = new Map<number, { resolve: Function, progress: IProgress<IProgressStep> }>();
+	private _progress = new Map<number, { resolve: () => void, progress: IProgress<IProgressStep> }>();
 	private _proxy: ExtHostProgressShape;

 	constructor(
--- a/src/vs/workbench/api/electron-browser/mainThreadQuickOpen.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadQuickOpen.ts
@@ -36,7 +36,7 @@ export class MainThreadQuickOpen implements MainThreadQuickOpenShape {
 	public dispose(): void {
 	}

-	$show(instance: number, options: IPickOptions<TransferQuickPickItems>, token: CancellationToken): Thenable<number | number[]> {
+	$show(instance: number, options: IPickOptions<TransferQuickPickItems>, token: CancellationToken): Promise<number | number[]> {
 		const contents = new Promise<TransferQuickPickItems[]>((resolve, reject) => {
 			this._items[instance] = { resolve, reject };
 		});
@@ -67,7 +67,7 @@ export class MainThreadQuickOpen implements MainThreadQuickOpenShape {
 		}
 	}

-	$setItems(instance: number, items: TransferQuickPickItems[]): Thenable<void> {
+	$setItems(instance: number, items: TransferQuickPickItems[]): Promise<void> {
 		if (this._items[instance]) {
 			this._items[instance].resolve(items);
 			delete this._items[instance];
@@ -75,7 +75,7 @@ export class MainThreadQuickOpen implements MainThreadQuickOpenShape {
 		return undefined;
 	}

-	$setError(instance: number, error: Error): Thenable<void> {
+	$setError(instance: number, error: Error): Promise<void> {
 		if (this._items[instance]) {
 			this._items[instance].reject(error);
 			delete this._items[instance];
@@ -85,7 +85,7 @@ export class MainThreadQuickOpen implements MainThreadQuickOpenShape {

 	// ---- input

-	$input(options: InputBoxOptions, validateInput: boolean, token: CancellationToken): Thenable<string> {
+	$input(options: InputBoxOptions, validateInput: boolean, token: CancellationToken): Promise<string> {
 		const inputOptions: IInputOptions = Object.create(null);

 		if (options) {
@@ -110,7 +110,7 @@ export class MainThreadQuickOpen implements MainThreadQuickOpenShape {

 	private sessions = new Map<number, QuickInputSession>();

-	$createOrUpdate(params: TransferQuickInput): Thenable<void> {
+	$createOrUpdate(params: TransferQuickInput): Promise<void> {
 		const sessionId = params.id;
 		let session = this.sessions.get(sessionId);
 		if (!session) {
@@ -202,7 +202,7 @@ export class MainThreadQuickOpen implements MainThreadQuickOpenShape {
 		return Promise.resolve(undefined);
 	}

-	$dispose(sessionId: number): Thenable<void> {
+	$dispose(sessionId: number): Promise<void> {
 		const session = this.sessions.get(sessionId);
 		if (session) {
 			session.input.dispose();
--- a/src/vs/workbench/api/electron-browser/mainThreadSCM.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadSCM.ts
@@ -3,9 +3,8 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { TPromise } from 'vs/base/common/winjs.base';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { Event, Emitter, debounceEvent } from 'vs/base/common/event';
+import { Event, Emitter } from 'vs/base/common/event';
 import { assign } from 'vs/base/common/objects';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { ISCMService, ISCMRepository, ISCMProvider, ISCMResource, ISCMResourceGroup, ISCMResourceDecorations, IInputValidation } from 'vs/workbench/services/scm/common/scm';
@@ -72,7 +71,7 @@ class MainThreadSCMResource implements ISCMResource {
 		public decorations: ISCMResourceDecorations
 	) { }

-	open(): Thenable<void> {
+	open(): Promise<void> {
 		return this.proxy.$executeResourceCommand(this.sourceControlHandle, this.groupHandle, this.handle);
 	}

@@ -242,13 +241,13 @@ class MainThreadSCMProvider implements ISCMProvider {
 		this.groups.splice(this.groups.elements.indexOf(group), 1);
 	}

-	getOriginalResource(uri: URI): TPromise<URI> {
+	async getOriginalResource(uri: URI): Promise<URI> {
 		if (!this.features.hasQuickDiffProvider) {
-			return TPromise.as(null);
+			return null;
 		}

-		return TPromise.wrap(this.proxy.$provideOriginalResource(this.handle, uri, CancellationToken.None))
-			.then(result => result && URI.revive(result));
+		const result = await this.proxy.$provideOriginalResource(this.handle, uri, CancellationToken.None);
+		return result && URI.revive(result);
 	}

 	toJSON(): any {
@@ -273,11 +272,11 @@ export class MainThreadSCM implements MainThreadSCMShape {

 	constructor(
 		extHostContext: IExtHostContext,
-		@ISCMService private scmService: ISCMService
+		@ISCMService private readonly scmService: ISCMService
 	) {
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostSCM);

-		debounceEvent(scmService.onDidChangeSelectedRepositories, (_, e) => e, 100)
+		Event.debounce(scmService.onDidChangeSelectedRepositories, (_, e) => e, 100)
 			(this.onDidChangeSelectedRepositories, this, this._disposables);
 	}

@@ -420,20 +419,12 @@ export class MainThreadSCM implements MainThreadSCMShape {
 		}

 		if (enabled) {
-			repository.input.validateInput = (value, pos): TPromise<IInputValidation | undefined> => {
-				return TPromise.wrap(this._proxy.$validateInput(sourceControlHandle, value, pos).then(result => {
-					if (!result) {
-						return undefined;
-					}
-
-					return {
-						message: result[0],
-						type: result[1]
-					};
-				}));
+			repository.input.validateInput = async (value, pos): Promise<IInputValidation | undefined> => {
+				const result = await this._proxy.$validateInput(sourceControlHandle, value, pos);
+				return result && { message: result[0], type: result[1] };
 			};
 		} else {
-			repository.input.validateInput = () => TPromise.as(undefined);
+			repository.input.validateInput = async () => undefined;
 		}
 	}

--- a/src/vs/workbench/api/electron-browser/mainThreadSaveParticipant.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadSaveParticipant.ts
@@ -3,39 +3,39 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { sequence, IdleValue } from 'vs/base/common/async';
+import { isNonEmptyArray } from 'vs/base/common/arrays';
+import { IdleValue, sequence } from 'vs/base/common/async';
+import { CancellationTokenSource, CancellationToken } from 'vs/base/common/cancellation';
 import * as strings from 'vs/base/common/strings';
+import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
+import { IBulkEditService } from 'vs/editor/browser/services/bulkEditService';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
-import { ISaveParticipant, ITextFileEditorModel, SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { ITextModel, ISingleEditOperation, IIdentifiedSingleEditOperation } from 'vs/editor/common/model';
+import { trimTrailingWhitespace } from 'vs/editor/common/commands/trimTrailingWhitespaceCommand';
+import { ICodeActionsOnSaveOptions } from 'vs/editor/common/config/editorOptions';
+import { EditOperation } from 'vs/editor/common/core/editOperation';
+import { Position } from 'vs/editor/common/core/position';
 import { Range } from 'vs/editor/common/core/range';
 import { Selection } from 'vs/editor/common/core/selection';
-import { Position } from 'vs/editor/common/core/position';
-import { trimTrailingWhitespace } from 'vs/editor/common/commands/trimTrailingWhitespaceCommand';
+import { IIdentifiedSingleEditOperation, ISingleEditOperation, ITextModel } from 'vs/editor/common/model';
+import { CodeAction } from 'vs/editor/common/modes';
+import { IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
+import { shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
+import { getCodeActions } from 'vs/editor/contrib/codeAction/codeAction';
+import { applyCodeAction } from 'vs/editor/contrib/codeAction/codeActionCommands';
+import { CodeActionKind } from 'vs/editor/contrib/codeAction/codeActionTrigger';
 import { getDocumentFormattingEdits, NoProviderError } from 'vs/editor/contrib/format/format';
 import { FormattingEdit } from 'vs/editor/contrib/format/formattingEdit';
-import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { TextFileEditorModel } from 'vs/workbench/services/textfile/common/textFileEditorModel';
-import { ExtHostContext, ExtHostDocumentSaveParticipantShape, IExtHostContext } from '../node/extHost.protocol';
-import { EditOperation } from 'vs/editor/common/core/editOperation';
-import { extHostCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
-import { IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
-import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
-import { IProgressService2, ProgressLocation } from 'vs/platform/progress/common/progress';
-import { localize } from 'vs/nls';
-import { isNonEmptyArray } from 'vs/base/common/arrays';
-import { ILogService } from 'vs/platform/log/common/log';
-import { shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
 import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
+import { localize } from 'vs/nls';
 import { ICommandService } from 'vs/platform/commands/common/commands';
-import { CodeActionKind } from 'vs/editor/contrib/codeAction/codeActionTrigger';
-import { CodeAction } from 'vs/editor/common/modes';
-import { applyCodeAction } from 'vs/editor/contrib/codeAction/codeActionCommands';
-import { getCodeActions } from 'vs/editor/contrib/codeAction/codeAction';
-import { ICodeActionsOnSaveOptions } from 'vs/editor/common/config/editorOptions';
-import { IBulkEditService } from 'vs/editor/browser/services/bulkEditService';
-import { CancellationTokenSource } from 'vs/base/common/cancellation';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IProgressService2, ProgressLocation } from 'vs/platform/progress/common/progress';
+import { extHostCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
+import { TextFileEditorModel } from 'vs/workbench/services/textfile/common/textFileEditorModel';
+import { ISaveParticipant, ITextFileEditorModel, SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
+import { ExtHostContext, ExtHostDocumentSaveParticipantShape, IExtHostContext } from '../node/extHost.protocol';

 // {{SQL CARBON EDIT}}
 import { INotebookService } from 'sql/workbench/services/notebook/common/notebookService';
@@ -55,12 +55,13 @@ class NotebookUpdateParticipant implements ISaveParticipantParticipant {
 		// Nothing
 	}

-	public participate(model: ITextFileEditorModel, env: { reason: SaveReason }): void {
+	public participate(model: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
 		let uriString = model.getResource().toString();
 		let notebookEditor = this.notebookService.listNotebookEditors().find((editor) => editor.id === uriString);
 		if (notebookEditor) {
 			notebookEditor.notebookParams.input.updateModel();
 		}
+		return Promise.resolve();
 	}
 }

@@ -71,13 +72,13 @@ export interface ISaveParticipantParticipant extends ISaveParticipant {
 class TrimWhitespaceParticipant implements ISaveParticipantParticipant {

 	constructor(
-		@IConfigurationService private configurationService: IConfigurationService,
-		@ICodeEditorService private codeEditorService: ICodeEditorService
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@ICodeEditorService private readonly codeEditorService: ICodeEditorService
 	) {
 		// Nothing
 	}

-	public participate(model: ITextFileEditorModel, env: { reason: SaveReason }): void {
+	async participate(model: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
 		if (this.configurationService.getValue('files.trimTrailingWhitespace', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
 			this.doTrimTrailingWhitespace(model.textEditorModel, env.reason === SaveReason.AUTO);
 		}
@@ -133,13 +134,13 @@ function findEditor(model: ITextModel, codeEditorService: ICodeEditorService): I
 export class FinalNewLineParticipant implements ISaveParticipantParticipant {

 	constructor(
-		@IConfigurationService private configurationService: IConfigurationService,
-		@ICodeEditorService private codeEditorService: ICodeEditorService
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@ICodeEditorService private readonly codeEditorService: ICodeEditorService
 	) {
 		// Nothing
 	}

-	public participate(model: ITextFileEditorModel, env: { reason: SaveReason }): void {
+	async participate(model: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
 		if (this.configurationService.getValue('files.insertFinalNewline', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
 			this.doInsertFinalNewLine(model.textEditorModel);
 		}
@@ -171,13 +172,13 @@ export class FinalNewLineParticipant implements ISaveParticipantParticipant {
 export class TrimFinalNewLinesParticipant implements ISaveParticipantParticipant {

 	constructor(
-		@IConfigurationService private configurationService: IConfigurationService,
-		@ICodeEditorService private codeEditorService: ICodeEditorService
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@ICodeEditorService private readonly codeEditorService: ICodeEditorService
 	) {
 		// Nothing
 	}

-	public participate(model: ITextFileEditorModel, env: { reason: SaveReason }): void {
+	async participate(model: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
 		if (this.configurationService.getValue('files.trimFinalNewlines', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
 			this.doTrimFinalNewLines(model.textEditorModel, env.reason === SaveReason.AUTO);
 		}
@@ -247,7 +248,7 @@ class FormatOnSaveParticipant implements ISaveParticipantParticipant {
 		// Nothing
 	}

-	participate(editorModel: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+	async participate(editorModel: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {

 		const model = editorModel.textEditorModel;
 		if (env.reason === SaveReason.AUTO
@@ -270,7 +271,7 @@ class FormatOnSaveParticipant implements ISaveParticipantParticipant {
 			}, timeout);

 			request.then(edits => this._editorWorkerService.computeMoreMinimalEdits(model.uri, edits)).then(resolve, err => {
-				if (!(err instanceof Error) || err.name !== NoProviderError.Name) {
+				if (!NoProviderError.is(err)) {
 					reject(err);
 				} else {
 					resolve();
@@ -317,7 +318,7 @@ class FormatOnSaveParticipant implements ISaveParticipantParticipant {
 	}
 }

-class CodeActionOnParticipant implements ISaveParticipant {
+class CodeActionOnSaveParticipant implements ISaveParticipant {

 	constructor(
 		@IBulkEditService private readonly _bulkEditService: IBulkEditService,
@@ -338,17 +339,49 @@ class CodeActionOnParticipant implements ISaveParticipant {
 			return undefined;
 		}

-		const codeActionsOnSave = Object.keys(setting).filter(x => setting[x]).map(x => new CodeActionKind(x));
+		const codeActionsOnSave = Object.keys(setting)
+			.filter(x => setting[x]).map(x => new CodeActionKind(x))
+			.sort((a, b) => {
+				if (a.value === CodeActionKind.SourceFixAll.value) {
+					return -1;
+				}
+				if (b.value === CodeActionKind.SourceFixAll.value) {
+					return 1;
+				}
+				return 0;
+			});
 		if (!codeActionsOnSave.length) {
 			return undefined;
 		}

+		const tokenSource = new CancellationTokenSource();
+
 		const timeout = this._configurationService.getValue<number>('editor.codeActionsOnSaveTimeout', settingsOverrides);

-		return new Promise<CodeAction[]>((resolve, reject) => {
-			setTimeout(() => reject(localize('codeActionsOnSave.didTimeout', "Aborted codeActionsOnSave after {0}ms", timeout)), timeout);
-			this.getActionsToRun(model, codeActionsOnSave).then(resolve);
-		}).then(actionsToRun => this.applyCodeActions(actionsToRun));
+		return Promise.race([
+			new Promise<void>((_resolve, reject) =>
+				setTimeout(() => {
+					tokenSource.cancel();
+					reject(localize('codeActionsOnSave.didTimeout', "Aborted codeActionsOnSave after {0}ms", timeout));
+				}, timeout)),
+			this.applyOnSaveActions(model, codeActionsOnSave, tokenSource.token)
+		]).then(() => {
+			tokenSource.cancel();
+		}, (e) => {
+			tokenSource.cancel();
+			return Promise.reject(e);
+		});
+	}
+
+	private async applyOnSaveActions(model: ITextModel, codeActionsOnSave: CodeActionKind[], token: CancellationToken): Promise<void> {
+		for (const codeActionKind of codeActionsOnSave) {
+			const actionsToRun = await this.getActionsToRun(model, codeActionKind, token);
+			try {
+				await this.applyCodeActions(actionsToRun);
+			} catch {
+				// Failure to apply a code action should not block other on save actions
+			}
+		}
 	}

 	private async applyCodeActions(actionsToRun: CodeAction[]) {
@@ -357,13 +390,11 @@ class CodeActionOnParticipant implements ISaveParticipant {
 		}
 	}

-	private async getActionsToRun(model: ITextModel, codeActionsOnSave: CodeActionKind[]) {
-		const actions = await getCodeActions(model, model.getFullModelRange(), {
+	private getActionsToRun(model: ITextModel, codeActionKind: CodeActionKind, token: CancellationToken) {
+		return getCodeActions(model, model.getFullModelRange(), {
 			type: 'auto',
-			filter: { kind: CodeActionKind.Source, includeSourceActions: true },
-		});
-		const actionsToRun = actions.filter(returnedAction => returnedAction.kind && codeActionsOnSave.some(onSaveKind => onSaveKind.contains(returnedAction.kind)));
-		return actionsToRun;
+			filter: { kind: codeActionKind, includeSourceActions: true },
+		}, token);
 	}
 }

@@ -375,7 +406,7 @@ class ExtHostSaveParticipant implements ISaveParticipantParticipant {
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant);
 	}

-	participate(editorModel: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+	async participate(editorModel: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {

 		if (!shouldSynchronizeModel(editorModel.textEditorModel)) {
 			// the model never made it to the extension
@@ -411,7 +442,7 @@ export class SaveParticipant implements ISaveParticipant {
 	) {
 		this._saveParticipants = new IdleValue(() => [
 			instantiationService.createInstance(TrimWhitespaceParticipant),
-			instantiationService.createInstance(CodeActionOnParticipant),
+			instantiationService.createInstance(CodeActionOnSaveParticipant),
 			instantiationService.createInstance(FormatOnSaveParticipant),
 			instantiationService.createInstance(FinalNewLineParticipant),
 			instantiationService.createInstance(TrimFinalNewLinesParticipant),
@@ -428,11 +459,11 @@ export class SaveParticipant implements ISaveParticipant {
 		this._saveParticipants.dispose();
 	}

-	participate(model: ITextFileEditorModel, env: { reason: SaveReason }): Thenable<void> {
+	async participate(model: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
 		return this._progressService.withProgress({ location: ProgressLocation.Window }, progress => {
 			progress.report({ message: localize('saveParticipants', "Running Save Participants...") });
 			const promiseFactory = this._saveParticipants.getValue().map(p => () => {
-				return Promise.resolve(p.participate(model, env));
+				return p.participate(model, env);
 			});
 			return sequence(promiseFactory).then(() => { }, err => this._logService.warn(err));
 		});
--- a/src/vs/workbench/api/electron-browser/mainThreadSearch.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadSearch.ts
@@ -140,7 +140,7 @@ class RemoteSearchProvider implements ISearchResultProvider, IDisposable {
 		return Promise.resolve(this._proxy.$clearCache(cacheKey));
 	}

-	handleFindMatch(session: number, dataOrUri: (UriComponents | IRawFileMatch2)[]): void {
+	handleFindMatch(session: number, dataOrUri: Array<UriComponents | IRawFileMatch2>): void {
 		if (!this._searches.has(session)) {
 			// ignore...
 			return;
--- a/src/vs/workbench/api/electron-browser/mainThreadStatusBar.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadStatusBar.ts
@@ -8,6 +8,7 @@ import { IDisposable } from 'vs/base/common/lifecycle';
 import { MainThreadStatusBarShape, MainContext, IExtHostContext } from '../node/extHost.protocol';
 import { ThemeColor } from 'vs/platform/theme/common/themeService';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

@extHostNamedCustomer(MainContext.MainThreadStatusBar)
 export class MainThreadStatusBar implements MainThreadStatusBarShape {
@@ -27,7 +28,7 @@ export class MainThreadStatusBar implements MainThreadStatusBarShape {
 		}
 	}

-	$setEntry(id: number, extensionId: string, text: string, tooltip: string, command: string, color: string | ThemeColor, alignment: MainThreadStatusBarAlignment, priority: number): void {
+	$setEntry(id: number, extensionId: ExtensionIdentifier, text: string, tooltip: string, command: string, color: string | ThemeColor, alignment: MainThreadStatusBarAlignment, priority: number): void {

 		// Dispose any old
 		this.$dispose(id);
--- a/src/vs/workbench/api/electron-browser/mainThreadStorage.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadStorage.ts
@@ -39,7 +39,7 @@ export class MainThreadStorage implements MainThreadStorageShape {
 		this._storageListener.dispose();
 	}

-	$getValue<T>(shared: boolean, key: string): Thenable<T> {
+	$getValue<T>(shared: boolean, key: string): Promise<T> {
 		if (shared) {
 			this._sharedStorageKeysToWatch.set(key, true);
 		}
@@ -58,7 +58,7 @@ export class MainThreadStorage implements MainThreadStorageShape {
 		return JSON.parse(jsonValue);
 	}

-	$setValue(shared: boolean, key: string, value: object): Thenable<void> {
+	$setValue(shared: boolean, key: string, value: object): Promise<void> {
 		let jsonValue: string;
 		try {
 			jsonValue = JSON.stringify(value);
--- a/src/vs/workbench/api/electron-browser/mainThreadTask.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadTask.ts
@@ -16,8 +16,8 @@ import { IDisposable } from 'vs/base/common/lifecycle';
 import { IWorkspaceContextService, IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';

 import {
-	ContributedTask, ExtensionTaskSourceTransfer, KeyedTaskIdentifier, TaskExecution, Task, TaskEvent, TaskEventKind,
-	PresentationOptions, CommandOptions, CommandConfiguration, RuntimeType, CustomTask, TaskScope, TaskSource, TaskSourceKind, ExtensionTaskSource, RevealKind, PanelKind, RunOptions
+	ContributedTask, KeyedTaskIdentifier, TaskExecution, Task, TaskEvent, TaskEventKind,
+	PresentationOptions, CommandOptions, CommandConfiguration, RuntimeType, CustomTask, TaskScope, TaskSource, TaskSourceKind, ExtensionTaskSource, RunOptions, TaskSet
 } from 'vs/workbench/parts/tasks/common/tasks';


@@ -76,7 +76,7 @@ namespace TaskDefinitionDTO {
 	}
 	export function to(value: TaskDefinitionDTO, executeOnly: boolean): KeyedTaskIdentifier {
 		let result = TaskDefinition.createTaskIdentifier(value, console);
-		if (result === void 0 && executeOnly) {
+		if (result === undefined && executeOnly) {
 			result = {
 				_key: generateUuid(),
 				type: '$executeOnly'
@@ -88,31 +88,37 @@ namespace TaskDefinitionDTO {

 namespace TaskPresentationOptionsDTO {
 	export function from(value: PresentationOptions): TaskPresentationOptionsDTO {
-		if (value === void 0 || value === null) {
+		if (value === undefined || value === null) {
 			return undefined;
 		}
 		return Objects.assign(Object.create(null), value);
 	}
 	export function to(value: TaskPresentationOptionsDTO): PresentationOptions {
-		if (value === void 0 || value === null) {
-			return { reveal: RevealKind.Always, echo: true, focus: false, panel: PanelKind.Shared, showReuseMessage: true, clear: false };
+		if (value === undefined || value === null) {
+			return PresentationOptions.defaults;
 		}
-		return Objects.assign(Object.create(null), value);
+		return Objects.assign(Object.create(null), PresentationOptions.defaults, value);
 	}
 }

 namespace RunOptionsDTO {
 	export function from(value: RunOptions): RunOptionsDTO {
-		if (value === void 0 || value === null) {
+		if (value === undefined || value === null) {
 			return undefined;
 		}
 		return Objects.assign(Object.create(null), value);
 	}
+	export function to(value: RunOptionsDTO): RunOptions {
+		if (value === undefined || value === null) {
+			return RunOptions.defaults;
+		}
+		return Objects.assign(Object.create(null), RunOptions.defaults, value);
+	}
 }

 namespace ProcessExecutionOptionsDTO {
 	export function from(value: CommandOptions): ProcessExecutionOptionsDTO {
-		if (value === void 0 || value === null) {
+		if (value === undefined || value === null) {
 			return undefined;
 		}
 		return {
@@ -121,11 +127,11 @@ namespace ProcessExecutionOptionsDTO {
 		};
 	}
 	export function to(value: ProcessExecutionOptionsDTO): CommandOptions {
-		if (value === void 0 || value === null) {
-			return undefined;
+		if (value === undefined || value === null) {
+			return CommandOptions.defaults;
 		}
 		return {
-			cwd: value.cwd,
+			cwd: value.cwd || CommandOptions.defaults.cwd,
 			env: value.env
 		};
 	}
@@ -155,20 +161,18 @@ namespace ProcessExecutionDTO {
 			args: value.args,
 			presentation: undefined
 		};
-		if (value.options) {
-			result.options = ProcessExecutionOptionsDTO.to(value.options);
-		}
+		result.options = ProcessExecutionOptionsDTO.to(value.options);
 		return result;
 	}
 }

 namespace ShellExecutionOptionsDTO {
 	export function from(value: CommandOptions): ShellExecutionOptionsDTO {
-		if (value === void 0 || value === null) {
+		if (value === undefined || value === null) {
 			return undefined;
 		}
 		let result: ShellExecutionOptionsDTO = {
-			cwd: value.cwd,
+			cwd: value.cwd || CommandOptions.defaults.cwd,
 			env: value.env
 		};
 		if (value.shell) {
@@ -179,7 +183,7 @@ namespace ShellExecutionOptionsDTO {
 		return result;
 	}
 	export function to(value: ShellExecutionOptionsDTO): CommandOptions {
-		if (value === void 0 || value === null) {
+		if (value === undefined || value === null) {
 			return undefined;
 		}
 		let result: CommandOptions = {
@@ -208,7 +212,7 @@ namespace ShellExecutionDTO {
 	}
 	export function from(value: CommandConfiguration): ShellExecutionDTO {
 		let result: ShellExecutionDTO = {};
-		if (value.name && Types.isString(value.name) && (value.args === void 0 || value.args === null || value.args.length === 0)) {
+		if (value.name && Types.isString(value.name) && (value.args === undefined || value.args === null || value.args.length === 0)) {
 			result.commandLine = value.name;
 		} else {
 			result.command = value.name;
@@ -254,7 +258,7 @@ namespace TaskSourceDTO {
 	export function to(value: TaskSourceDTO, workspace: IWorkspaceContextService): ExtensionTaskSource {
 		let scope: TaskScope;
 		let workspaceFolder: IWorkspaceFolder;
-		if ((value.scope === void 0) || ((typeof value.scope === 'number') && (value.scope !== TaskScope.Global))) {
+		if ((value.scope === undefined) || ((typeof value.scope === 'number') && (value.scope !== TaskScope.Global))) {
 			if (workspace.getWorkspace().folders.length === 0) {
 				scope = TaskScope.Global;
 				workspaceFolder = undefined;
@@ -288,23 +292,23 @@ namespace TaskHandleDTO {

 namespace TaskDTO {
 	export function from(task: Task): TaskDTO {
-		if (task === void 0 || task === null || (!CustomTask.is(task) && !ContributedTask.is(task))) {
+		if (task === undefined || task === null || (!CustomTask.is(task) && !ContributedTask.is(task))) {
 			return undefined;
 		}
 		let result: TaskDTO = {
 			_id: task._id,
-			name: task.name,
-			definition: TaskDefinitionDTO.from(Task.getTaskDefinition(task)),
+			name: task.configurationProperties.name,
+			definition: TaskDefinitionDTO.from(task.getDefinition()),
 			source: TaskSourceDTO.from(task._source),
 			execution: undefined,
 			presentationOptions: task.command ? TaskPresentationOptionsDTO.from(task.command.presentation) : undefined,
-			isBackground: task.isBackground,
+			isBackground: task.configurationProperties.isBackground,
 			problemMatchers: [],
 			hasDefinedMatchers: ContributedTask.is(task) ? task.hasDefinedMatchers : false,
 			runOptions: RunOptionsDTO.from(task.runOptions),
 		};
-		if (task.group) {
-			result.group = task.group;
+		if (task.configurationProperties.group) {
+			result.group = task.configurationProperties.group;
 		}
 		if (task.command) {
 			if (task.command.runtime === RuntimeType.Process) {
@@ -313,8 +317,8 @@ namespace TaskDTO {
 				result.execution = ShellExecutionDTO.from(task.command);
 			}
 		}
-		if (task.problemMatchers) {
-			for (let matcher of task.problemMatchers) {
+		if (task.configurationProperties.problemMatchers) {
+			for (let matcher of task.configurationProperties.problemMatchers) {
 				if (Types.isString(matcher)) {
 					result.problemMatchers.push(matcher);
 				}
@@ -323,7 +327,7 @@ namespace TaskDTO {
 		return result;
 	}

-	export function to(task: TaskDTO, workspace: IWorkspaceContextService, executeOnly: boolean): Task {
+	export function to(task: TaskDTO, workspace: IWorkspaceContextService, executeOnly: boolean): ContributedTask {
 		if (typeof task.name !== 'string') {
 			return undefined;
 		}
@@ -337,28 +341,28 @@ namespace TaskDTO {
 			return undefined;
 		}
 		command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
-		command.presentation = Objects.assign(command.presentation || ({} as PresentationOptions), { echo: true, reveal: RevealKind.Always, focus: false, panel: PanelKind.Shared });
-
 		let source = TaskSourceDTO.to(task.source, workspace);

 		let label = nls.localize('task.label', '{0}: {1}', source.label, task.name);
 		let definition = TaskDefinitionDTO.to(task.definition, executeOnly);
 		let id = `${task.source.extensionId}.${definition._key}`;
-		let result: ContributedTask = {
-			_id: id, // uuidMap.getUUID(identifier)
-			_source: source,
-			_label: label,
-			type: definition.type,
-			defines: definition,
-			name: task.name,
-			identifier: label,
-			group: task.group,
-			command: command,
-			isBackground: !!task.isBackground,
-			problemMatchers: task.problemMatchers.slice(),
-			hasDefinedMatchers: task.hasDefinedMatchers,
-			runOptions: task.runOptions,
-		};
+		let result: ContributedTask = new ContributedTask(
+			id, // uuidMap.getUUID(identifier)
+			source,
+			label,
+			definition.type,
+			definition,
+			command,
+			task.hasDefinedMatchers,
+			RunOptionsDTO.to(task.runOptions),
+			{
+				name: task.name,
+				identifier: label,
+				group: task.group,
+				isBackground: !!task.isBackground,
+				problemMatchers: task.problemMatchers.slice(),
+			}
+		);
 		return result;
 	}
 }
@@ -390,13 +394,13 @@ export class MainThreadTask implements MainThreadTaskShape {
 		this._taskService.onDidStateChange((event: TaskEvent) => {
 			let task = event.__task;
 			if (event.kind === TaskEventKind.Start) {
-				this._proxy.$onDidStartTask(TaskExecutionDTO.from(Task.getTaskExecution(task)));
+				this._proxy.$onDidStartTask(TaskExecutionDTO.from(task.getTaskExecution()));
 			} else if (event.kind === TaskEventKind.ProcessStarted) {
-				this._proxy.$onDidStartTaskProcess(TaskProcessStartedDTO.from(Task.getTaskExecution(task), event.processId));
+				this._proxy.$onDidStartTaskProcess(TaskProcessStartedDTO.from(task.getTaskExecution(), event.processId));
 			} else if (event.kind === TaskEventKind.ProcessEnded) {
-				this._proxy.$onDidEndTaskProcess(TaskProcessEndedDTO.from(Task.getTaskExecution(task), event.exitCode));
+				this._proxy.$onDidEndTaskProcess(TaskProcessEndedDTO.from(task.getTaskExecution(), event.exitCode));
 			} else if (event.kind === TaskEventKind.End) {
-				this._proxy.$OnDidEndTask(TaskExecutionDTO.from(Task.getTaskExecution(task)));
+				this._proxy.$OnDidEndTask(TaskExecutionDTO.from(task.getTaskExecution()));
 			}
 		});
 	}
@@ -408,29 +412,23 @@ export class MainThreadTask implements MainThreadTaskShape {
 		this._providers.clear();
 	}

-	public $registerTaskProvider(handle: number): Thenable<void> {
+	public $registerTaskProvider(handle: number): Promise<void> {
 		let provider: ITaskProvider = {
 			provideTasks: (validTypes: IStringDictionary<boolean>) => {
 				return Promise.resolve(this._proxy.$provideTasks(handle, validTypes)).then((value) => {
 					let tasks: Task[] = [];
-					for (let task of value.tasks) {
-						let taskTransfer = task._source as any as ExtensionTaskSourceTransfer;
-						if (taskTransfer.__workspaceFolder !== void 0 && taskTransfer.__definition !== void 0) {
-							(task._source as any).workspaceFolder = this._workspaceContextServer.getWorkspaceFolder(URI.revive(taskTransfer.__workspaceFolder));
-							delete taskTransfer.__workspaceFolder;
-							let taskIdentifier = TaskDefinition.createTaskIdentifier(taskTransfer.__definition, console);
-							delete taskTransfer.__definition;
-							if (taskIdentifier !== void 0) {
-								(task as ContributedTask).defines = taskIdentifier;
-								task._id = `${task._id}.${taskIdentifier._key}`;
-								tasks.push(task);
-							}
+					for (let dto of value.tasks) {
+						let task = TaskDTO.to(dto, this._workspaceContextServer, true);
+						if (task) {
+							tasks.push(task);
 						} else {
-							console.warn(`Dropping task ${task.name}. Missing workspace folder and task definition`);
+							console.error(`Task System: can not convert task: ${JSON.stringify(dto.definition, undefined, 0)}. Task will be dropped`);
 						}
 					}
-					value.tasks = tasks;
-					return value;
+					return {
+						tasks,
+						extension: value.extension
+					} as TaskSet;
 				});
 			}
 		};
@@ -439,12 +437,12 @@ export class MainThreadTask implements MainThreadTaskShape {
 		return Promise.resolve(undefined);
 	}

-	public $unregisterTaskProvider(handle: number): Thenable<void> {
+	public $unregisterTaskProvider(handle: number): Promise<void> {
 		this._providers.delete(handle);
 		return Promise.resolve(undefined);
 	}

-	public $fetchTasks(filter?: TaskFilterDTO): Thenable<TaskDTO[]> {
+	public $fetchTasks(filter?: TaskFilterDTO): Promise<TaskDTO[]> {
 		return this._taskService.tasks(TaskFilterDTO.to(filter)).then((tasks) => {
 			let result: TaskDTO[] = [];
 			for (let task of tasks) {
@@ -457,7 +455,7 @@ export class MainThreadTask implements MainThreadTaskShape {
 		});
 	}

-	public $executeTask(value: TaskHandleDTO | TaskDTO): Thenable<TaskExecutionDTO> {
+	public $executeTask(value: TaskHandleDTO | TaskDTO): Promise<TaskExecutionDTO> {
 		return new Promise<TaskExecutionDTO>((resolve, reject) => {
 			if (TaskHandleDTO.is(value)) {
 				let workspaceFolder = this._workspaceContextServer.getWorkspaceFolder(URI.revive(value.workspaceFolder));
@@ -487,7 +485,7 @@ export class MainThreadTask implements MainThreadTaskShape {
 		});
 	}

-	public $terminateTask(id: string): Thenable<void> {
+	public $terminateTask(id: string): Promise<void> {
 		return new Promise<void>((resolve, reject) => {
 			this._taskService.getActiveTasks().then((tasks) => {
 				for (let task of tasks) {
--- a/src/vs/workbench/api/electron-browser/mainThreadTerminalService.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadTerminalService.ts
@@ -20,7 +20,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape

 	constructor(
 		extHostContext: IExtHostContext,
-		@ITerminalService private terminalService: ITerminalService
+		@ITerminalService private readonly terminalService: ITerminalService
 	) {
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTerminalService);
 		this._remoteAuthority = extHostContext.remoteAuthority;
@@ -55,7 +55,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		// when the extension host process goes down ?
 	}

-	public $createTerminal(name?: string, shellPath?: string, shellArgs?: string[], cwd?: string, env?: { [key: string]: string }, waitOnExit?: boolean): Thenable<number> {
+	public $createTerminal(name?: string, shellPath?: string, shellArgs?: string[], cwd?: string, env?: { [key: string]: string }, waitOnExit?: boolean, strictEnv?: boolean): Promise<{ id: number, name: string }> {
 		const shellLaunchConfig: IShellLaunchConfig = {
 			name,
 			executable: shellPath,
@@ -63,12 +63,17 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 			cwd,
 			waitOnExit,
 			ignoreConfigurationCwd: true,
-			env
+			env,
+			strictEnv
 		};
-		return Promise.resolve(this.terminalService.createTerminal(shellLaunchConfig).id);
+		const terminal = this.terminalService.createTerminal(shellLaunchConfig);
+		return Promise.resolve({
+			id: terminal.id,
+			name: terminal.title
+		});
 	}

-	public $createTerminalRenderer(name: string): Thenable<number> {
+	public $createTerminalRenderer(name: string): Promise<number> {
 		const instance = this.terminalService.createTerminalRenderer(name);
 		return Promise.resolve(instance.id);
 	}
@@ -216,6 +221,8 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		request.proxy.onInput(data => this._proxy.$acceptProcessInput(request.proxy.terminalId, data));
 		request.proxy.onResize(dimensions => this._proxy.$acceptProcessResize(request.proxy.terminalId, dimensions.cols, dimensions.rows));
 		request.proxy.onShutdown(immediate => this._proxy.$acceptProcessShutdown(request.proxy.terminalId, immediate));
+		request.proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(request.proxy.terminalId));
+		request.proxy.onRequestInitialCwd(() => this._proxy.$acceptProcessRequestInitialCwd(request.proxy.terminalId));
 	}

 	public $sendProcessTitle(terminalId: number, title: string): void {
@@ -234,4 +241,12 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		this._terminalProcesses[terminalId].emitExit(exitCode);
 		delete this._terminalProcesses[terminalId];
 	}
+
+	public $sendProcessInitialCwd(terminalId: number, initialCwd: string): void {
+		this._terminalProcesses[terminalId].emitInitialCwd(initialCwd);
+	}
+
+	public $sendProcessCwd(terminalId: number, cwd: string): void {
+		this._terminalProcesses[terminalId].emitCwd(cwd);
+	}
 }
--- a/src/vs/workbench/api/electron-browser/mainThreadTreeViews.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadTreeViews.ts
@@ -5,7 +5,7 @@

 import { Disposable } from 'vs/base/common/lifecycle';
 import { ExtHostContext, MainThreadTreeViewsShape, ExtHostTreeViewsShape, MainContext, IExtHostContext } from '../node/extHost.protocol';
-import { ITreeViewDataProvider, ITreeItem, IViewsService, ITreeView, ViewsRegistry, ICustomViewDescriptor, IRevealOptions } from 'vs/workbench/common/views';
+import { ITreeViewDataProvider, ITreeItem, IViewsService, ITreeView, ViewsRegistry, ITreeViewDescriptor, IRevealOptions } from 'vs/workbench/common/views';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { distinct } from 'vs/base/common/arrays';
 import { INotificationService } from 'vs/platform/notification/common/notification';
@@ -20,8 +20,8 @@ export class MainThreadTreeViews extends Disposable implements MainThreadTreeVie

 	constructor(
 		extHostContext: IExtHostContext,
-		@IViewsService private viewsService: IViewsService,
-		@INotificationService private notificationService: INotificationService,
+		@IViewsService private readonly viewsService: IViewsService,
+		@INotificationService private readonly notificationService: INotificationService
 	) {
 		super();
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTreeViews);
@@ -41,7 +41,7 @@ export class MainThreadTreeViews extends Disposable implements MainThreadTreeVie
 		}
 	}

-	$reveal(treeViewId: string, item: ITreeItem, parentChain: ITreeItem[], options: IRevealOptions): Thenable<void> {
+	$reveal(treeViewId: string, item: ITreeItem, parentChain: ITreeItem[], options: IRevealOptions): Promise<void> {
 		return this.viewsService.openView(treeViewId, options.focus)
 			.then(() => {
 				const viewer = this.getTreeView(treeViewId);
@@ -49,12 +49,12 @@ export class MainThreadTreeViews extends Disposable implements MainThreadTreeVie
 			});
 	}

-	$refresh(treeViewId: string, itemsToRefreshByHandle: { [treeItemHandle: string]: ITreeItem }): Thenable<void> {
+	$refresh(treeViewId: string, itemsToRefreshByHandle: { [treeItemHandle: string]: ITreeItem }): Promise<void> {
 		const viewer = this.getTreeView(treeViewId);
 		const dataProvider = this._dataProviders.get(treeViewId);
 		if (viewer && dataProvider) {
 			const itemsToRefresh = dataProvider.getItemsToRefresh(itemsToRefreshByHandle);
-			return viewer.refresh(itemsToRefresh.length ? itemsToRefresh : void 0);
+			return viewer.refresh(itemsToRefresh.length ? itemsToRefresh : undefined);
 		}
 		return null;
 	}
@@ -110,7 +110,7 @@ export class MainThreadTreeViews extends Disposable implements MainThreadTreeVie
 	}

 	private getTreeView(treeViewId: string): ITreeView {
-		const viewDescriptor: ICustomViewDescriptor = <ICustomViewDescriptor>ViewsRegistry.getView(treeViewId);
+		const viewDescriptor: ITreeViewDescriptor = <ITreeViewDescriptor>ViewsRegistry.getView(treeViewId);
 		return viewDescriptor ? viewDescriptor.treeView : null;
 	}

@@ -143,7 +143,7 @@ export class TreeViewDataProvider implements ITreeViewDataProvider {
 	}

 	getChildren(treeItem?: ITreeItem): Promise<ITreeItem[]> {
-		return Promise.resolve(this._proxy.$getChildren(this.treeViewId, treeItem ? treeItem.handle : void 0)
+		return Promise.resolve(this._proxy.$getChildren(this.treeViewId, treeItem ? treeItem.handle : undefined)
 			.then(
 				children => this.postGetChildren(children),
 				err => {
--- a/src/vs/workbench/api/electron-browser/mainThreadUrls.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadUrls.ts
@@ -9,17 +9,18 @@ import { IURLService, IURLHandler } from 'vs/platform/url/common/url';
 import { URI } from 'vs/base/common/uri';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { IExtensionUrlHandler } from 'vs/workbench/services/extensions/electron-browser/inactiveExtensionUrlHandler';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 class ExtensionUrlHandler implements IURLHandler {

 	constructor(
 		private readonly proxy: ExtHostUrlsShape,
 		private readonly handle: number,
-		readonly extensionId: string
+		readonly extensionId: ExtensionIdentifier
 	) { }

 	handleURL(uri: URI): Promise<boolean> {
-		if (uri.authority !== this.extensionId) {
+		if (!ExtensionIdentifier.equals(this.extensionId, uri.authority)) {
 			return Promise.resolve(false);
 		}

@@ -31,31 +32,31 @@ class ExtensionUrlHandler implements IURLHandler {
 export class MainThreadUrls implements MainThreadUrlsShape {

 	private readonly proxy: ExtHostUrlsShape;
-	private handlers = new Map<number, { extensionId: string, disposable: IDisposable }>();
+	private handlers = new Map<number, { extensionId: ExtensionIdentifier, disposable: IDisposable }>();

 	constructor(
 		context: IExtHostContext,
-		@IURLService private urlService: IURLService,
-		@IExtensionUrlHandler private inactiveExtensionUrlHandler: IExtensionUrlHandler
+		@IURLService private readonly urlService: IURLService,
+		@IExtensionUrlHandler private readonly inactiveExtensionUrlHandler: IExtensionUrlHandler
 	) {
 		this.proxy = context.getProxy(ExtHostContext.ExtHostUrls);
 	}

-	$registerUriHandler(handle: number, extensionId: string): Thenable<void> {
+	$registerUriHandler(handle: number, extensionId: ExtensionIdentifier): Promise<void> {
 		const handler = new ExtensionUrlHandler(this.proxy, handle, extensionId);
 		const disposable = this.urlService.registerHandler(handler);

 		this.handlers.set(handle, { extensionId, disposable });
 		this.inactiveExtensionUrlHandler.registerExtensionHandler(extensionId, handler);

-		return Promise.resolve(null);
+		return Promise.resolve(undefined);
 	}

-	$unregisterUriHandler(handle: number): Thenable<void> {
+	$unregisterUriHandler(handle: number): Promise<void> {
 		const tuple = this.handlers.get(handle);

 		if (!tuple) {
-			return Promise.resolve(null);
+			return Promise.resolve(undefined);
 		}

 		const { extensionId, disposable } = tuple;
@@ -64,7 +65,7 @@ export class MainThreadUrls implements MainThreadUrlsShape {
 		this.handlers.delete(handle);
 		disposable.dispose();

-		return Promise.resolve(null);
+		return Promise.resolve(undefined);
 	}

 	dispose(): void {
--- a/src/vs/workbench/api/electron-browser/mainThreadWebview.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadWebview.ts
@@ -19,6 +19,8 @@ import { IEditorGroupsService } from 'vs/workbench/services/group/common/editorG
 import * as vscode from 'vscode';
 import { extHostNamedCustomer } from './extHostCustomers';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

@extHostNamedCustomer(MainContext.MainThreadWebviews)
 export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviver {
@@ -68,7 +70,7 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 		title: string,
 		showOptions: { viewColumn: EditorViewColumn | null, preserveFocus: boolean },
 		options: WebviewInputOptions,
-		extensionId: string,
+		extensionId: ExtensionIdentifier,
 		extensionLocation: UriComponents
 	): void {
 		const mainThreadShowOptions: ICreateWebViewShowOptions = Object.create(null);
@@ -91,7 +93,7 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 				"extensionId" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
 			}
 		*/
-		this._telemetryService.publicLog('webviews:createWebviewPanel', { extensionId: extensionId });
+		this._telemetryService.publicLog('webviews:createWebviewPanel', { extensionId: extensionId.value });
 	}

 	public $disposeWebview(handle: WebviewPanelHandle): void {
@@ -130,7 +132,7 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 		this._webviewService.revealWebview(webview, targetGroup || this._editorGroupService.activeGroup, showOptions.preserveFocus);
 	}

-	public $postMessage(handle: WebviewPanelHandle, message: any): Thenable<boolean> {
+	public $postMessage(handle: WebviewPanelHandle, message: any): Promise<boolean> {
 		const webview = this.getWebview(handle);
 		const editors = this._editorService.visibleControls
 			.filter(e => e instanceof WebviewEditor)
@@ -169,7 +171,9 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 			}

 			return this._proxy.$deserializeWebviewPanel(handle, webview.state.viewType, webview.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webview.group), webview.options)
-				.then(undefined, () => {
+				.then(undefined, error => {
+					onUnexpectedError(error);
+
 					webview.html = MainThreadWebviews.getDeserializationFailedContents(viewType);
 				});
 		}));
--- a/src/vs/workbench/api/electron-browser/mainThreadWindow.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadWindow.ts
@@ -3,11 +3,12 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { IWindowService } from 'vs/platform/windows/common/windows';
-import { MainThreadWindowShape, ExtHostWindowShape, ExtHostContext, MainContext, IExtHostContext } from '../node/extHost.protocol';
-import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { Event } from 'vs/base/common/event';
+import { dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IWindowService, IWindowsService } from 'vs/platform/windows/common/windows';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
-import { latch } from 'vs/base/common/event';
+import { ExtHostContext, ExtHostWindowShape, IExtHostContext, MainContext, MainThreadWindowShape } from '../node/extHost.protocol';

@extHostNamedCustomer(MainContext.MainThreadWindow)
 export class MainThreadWindow implements MainThreadWindowShape {
@@ -17,19 +18,24 @@ export class MainThreadWindow implements MainThreadWindowShape {

 	constructor(
 		extHostContext: IExtHostContext,
-		@IWindowService private windowService: IWindowService
+		@IWindowService private readonly windowService: IWindowService,
+		@IWindowsService private readonly windowsService: IWindowsService
 	) {
 		this.proxy = extHostContext.getProxy(ExtHostContext.ExtHostWindow);

-		latch(windowService.onDidChangeFocus)
+		Event.latch(windowService.onDidChangeFocus)
 			(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
 	}

-	$getWindowVisibility(): Thenable<boolean> {
-		return this.windowService.isFocused();
-	}
-
 	dispose(): void {
 		this.disposables = dispose(this.disposables);
 	}
+
+	$getWindowVisibility(): Promise<boolean> {
+		return this.windowService.isFocused();
+	}
+
+	$openUri(uri: UriComponents): Promise<boolean> {
+		return this.windowsService.openExternal(URI.revive(uri).toString(true));
+	}
 }
--- a/src/vs/workbench/api/electron-browser/mainThreadWorkspace.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadWorkspace.ts
@@ -9,10 +9,9 @@ import { URI, UriComponents } from 'vs/base/common/uri';
 import { localize } from 'vs/nls';
 import { CommandsRegistry } from 'vs/platform/commands/common/commands';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { ILabelService } from 'vs/platform/label/common/label';
-import { IFolderQuery, IPatternInfo, ISearchConfiguration, ISearchProgressItem, ISearchService, QueryType, IFileQuery } from 'vs/platform/search/common/search';
+import { IFolderQuery, IPatternInfo, ISearchConfiguration, ISearchProgressItem, ISearchService, QueryType, IFileQuery, IFileMatch } from 'vs/platform/search/common/search';
 import { IStatusbarService } from 'vs/platform/statusbar/common/statusbar';
 import { IWindowService } from 'vs/platform/windows/common/windows';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
@@ -24,6 +23,7 @@ import { IWorkspaceEditingService } from 'vs/workbench/services/workspace/common
 import { ExtHostContext, ExtHostWorkspaceShape, IExtHostContext, MainContext, MainThreadWorkspaceShape } from '../node/extHost.protocol';
 import { CancellationTokenSource, CancellationToken } from 'vs/base/common/cancellation';
 import { TextSearchComplete } from 'vscode';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

@extHostNamedCustomer(MainContext.MainThreadWorkspace)
 export class MainThreadWorkspace implements MainThreadWorkspaceShape {
@@ -60,7 +60,7 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {

 	// --- workspace ---

-	$updateWorkspaceFolders(extensionName: string, index: number, deleteCount: number, foldersToAdd: { uri: UriComponents, name?: string }[]): Thenable<void> {
+	$updateWorkspaceFolders(extensionName: string, index: number, deleteCount: number, foldersToAdd: { uri: UriComponents, name?: string }[]): Promise<void> {
 		const workspaceFoldersToAdd = foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name }));

 		// Indicate in status message
@@ -113,7 +113,7 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {

 	// --- search ---

-	$startFileSearch(includePattern: string, _includeFolder: UriComponents, excludePatternOrDisregardExcludes: string | false, maxResults: number, token: CancellationToken): Thenable<URI[]> {
+	$startFileSearch(includePattern: string, _includeFolder: UriComponents, excludePatternOrDisregardExcludes: string | false, maxResults: number, token: CancellationToken): Promise<URI[]> {
 		const includeFolder = URI.revive(_includeFolder);
 		const workspace = this._contextService.getWorkspace();
 		if (!workspace.folders.length) {
@@ -131,11 +131,6 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 			return undefined; // invalid query parameters
 		}

-		const useRipgrep = folderQueries.every(folderQuery => {
-			const folderConfig = this._configurationService.getValue<ISearchConfiguration>({ resource: folderQuery.folder });
-			return folderConfig.search.useRipgrep;
-		});
-
 		const ignoreSymlinks = folderQueries.every(folderQuery => {
 			const folderConfig = this._configurationService.getValue<ISearchConfiguration>({ resource: folderQuery.folder });
 			return !folderConfig.search.followSymlinks;
@@ -151,7 +146,6 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 			type: QueryType.File,
 			maxResults,
 			disregardExcludeSettings: excludePatternOrDisregardExcludes === false,
-			useRipgrep,
 			_reason: 'startFileSearch'
 		};
 		if (typeof includePattern === 'string') {
@@ -174,7 +168,7 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 		});
 	}

-	$startTextSearch(pattern: IPatternInfo, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Thenable<TextSearchComplete> {
+	$startTextSearch(pattern: IPatternInfo, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Promise<TextSearchComplete> {
 		const workspace = this._contextService.getWorkspace();
 		const folders = workspace.folders.map(folder => folder.uri);

@@ -183,8 +177,8 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 		query._reason = 'startTextSearch';

 		const onProgress = (p: ISearchProgressItem) => {
-			if (p.results) {
-				this._proxy.$handleTextSearchResult(p, requestId);
+			if ((<IFileMatch>p).results) {
+				this._proxy.$handleTextSearchResult(<IFileMatch>p, requestId);
 			}
 		};

@@ -203,7 +197,7 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 		return search;
 	}

-	$checkExists(includes: string[], token: CancellationToken): Thenable<boolean> {
+	$checkExists(includes: string[], token: CancellationToken): Promise<boolean> {
 		const queryBuilder = this._instantiationService.createInstance(QueryBuilder);
 		const folders = this._contextService.getWorkspace().folders.map(folder => folder.uri);
 		const query = queryBuilder.file(folders, {
@@ -227,13 +221,13 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {

 	// --- save & edit resources ---

-	$saveAll(includeUntitled?: boolean): Thenable<boolean> {
+	$saveAll(includeUntitled?: boolean): Promise<boolean> {
 		return this._textFileService.saveAll(includeUntitled).then(result => {
 			return result.results.every(each => each.success === true);
 		});
 	}

-	$resolveProxy(url: string): Thenable<string> {
+	$resolveProxy(url: string): Promise<string> {
 		return this._windowService.resolveProxy(url);
 	}
 }
@@ -246,10 +240,10 @@ CommandsRegistry.registerCommand('_workbench.enterWorkspace', async function (ac
 	if (disableExtensions && disableExtensions.length) {
 		const runningExtensions = await extensionService.getExtensions();
 		// If requested extension to disable is running, then reload window with given workspace
-		if (disableExtensions && runningExtensions.some(runningExtension => disableExtensions.some(id => areSameExtensions({ id }, { id: runningExtension.id })))) {
+		if (disableExtensions && runningExtensions.some(runningExtension => disableExtensions.some(id => ExtensionIdentifier.equals(runningExtension.identifier, id)))) {
 			return windowService.openWindow([URI.file(workspace.fsPath)], { args: { _: [], 'disable-extension': disableExtensions } });
 		}
 	}

-	return workspaceEditingService.enterWorkspace(workspace.fsPath);
+	return workspaceEditingService.enterWorkspace(workspace);
 });