Merge from vscode fc10e26ea50f82cdd84e9141491357922e6f5fba (#4639)

src/vs/workbench/api/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/common/extHostCustomers';
+import { MainContext, MainThreadConsoleShape, IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IRemoteConsoleLog, log, parse } from 'vs/base/common/console';
+import { parseExtensionDevOptions } from 'vs/workbench/services/extensions/common/extensionDevOptions';
+import { IWindowsService } from 'vs/platform/windows/common/windows';
+import { IBroadcastService } from 'vs/workbench/services/broadcast/common/broadcast';
+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
+				}
+			});
+		}
+	}
+}

src/vs/workbench/api/browser/mainThreadDocumentContentProviders.ts

@@ -41,14 +41,14 @@ export class MainThreadDocumentContentProviders implements MainThreadDocumentCon
 
 	$registerTextContentProvider(handle: number, scheme: string): void {
 		const registration = this._textModelResolverService.registerTextModelContentProvider(scheme, {
-			provideTextContent: (uri: URI): Promise<ITextModel | undefined> => {
+			provideTextContent: (uri: URI): Promise<ITextModel | null> => {
 				return this._proxy.$provideTextDocumentContent(handle, uri).then(value => {
 					if (typeof value === 'string') {
 						const firstLineText = value.substr(0, 1 + value.search(/\r?\n/));
 						const languageSelection = this._modeService.createByFilepathOrFirstLine(uri.fsPath, firstLineText);
 						return this._modelService.createModel(value, languageSelection, uri);
 					}
-					return undefined;
+					return null;
 				});
 			}
 		});

src/vs/workbench/api/browser/mainThreadDocuments.ts

@@ -0,0 +1,244 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { toErrorMessage } from 'vs/base/common/errorMessage';
+import { IDisposable, IReference, dispose } from 'vs/base/common/lifecycle';
+import { Schemas } from 'vs/base/common/network';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { ITextModel } from 'vs/editor/common/model';
+import { IModeService } from 'vs/editor/common/services/modeService';
+import { IModelService, shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
+import { IFileService } from 'vs/platform/files/common/files';
+import { MainThreadDocumentsAndEditors } from 'vs/workbench/api/browser/mainThreadDocumentsAndEditors';
+import { ExtHostContext, ExtHostDocumentsShape, IExtHostContext, MainThreadDocumentsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ITextEditorModel } from 'vs/workbench/common/editor';
+import { ITextFileService, TextFileModelChangeEvent } from 'vs/workbench/services/textfile/common/textfiles';
+import { IUntitledEditorService } from 'vs/workbench/services/untitled/common/untitledEditorService';
+
+export class BoundModelReferenceCollection {
+
+	private _data = new Array<{ length: number, dispose(): void }>();
+	private _length = 0;
+
+	constructor(
+		private readonly _maxAge: number = 1000 * 60 * 3,
+		private readonly _maxLength: number = 1024 * 1024 * 80
+	) {
+		//
+	}
+
+	dispose(): void {
+		this._data = dispose(this._data);
+	}
+
+	add(ref: IReference<ITextEditorModel>): void {
+		const length = ref.object.textEditorModel.getValueLength();
+		let handle: any;
+		let entry: { length: number, dispose(): void };
+		const dispose = () => {
+			const idx = this._data.indexOf(entry);
+			if (idx >= 0) {
+				this._length -= length;
+				ref.dispose();
+				clearTimeout(handle);
+				this._data.splice(idx, 1);
+			}
+		};
+		handle = setTimeout(dispose, this._maxAge);
+		entry = { length, dispose };
+
+		this._data.push(entry);
+		this._length += length;
+		this._cleanup();
+	}
+
+	private _cleanup(): void {
+		while (this._length > this._maxLength) {
+			this._data[0].dispose();
+		}
+	}
+}
+
+export class MainThreadDocuments implements MainThreadDocumentsShape {
+
+	private readonly _modelService: IModelService;
+	private readonly _textModelResolverService: ITextModelService;
+	private readonly _textFileService: ITextFileService;
+	private readonly _fileService: IFileService;
+	private readonly _untitledEditorService: IUntitledEditorService;
+
+	private _toDispose: IDisposable[];
+	private _modelToDisposeMap: { [modelUrl: string]: IDisposable; };
+	private readonly _proxy: ExtHostDocumentsShape;
+	private readonly _modelIsSynced: { [modelId: string]: boolean; };
+	private _modelReferenceCollection = new BoundModelReferenceCollection();
+
+	constructor(
+		documentsAndEditors: MainThreadDocumentsAndEditors,
+		extHostContext: IExtHostContext,
+		@IModelService modelService: IModelService,
+		@IModeService modeService: IModeService,
+		@ITextFileService textFileService: ITextFileService,
+		@IFileService fileService: IFileService,
+		@ITextModelService textModelResolverService: ITextModelService,
+		@IUntitledEditorService untitledEditorService: IUntitledEditorService,
+	) {
+		this._modelService = modelService;
+		this._textModelResolverService = textModelResolverService;
+		this._textFileService = textFileService;
+		this._fileService = fileService;
+		this._untitledEditorService = untitledEditorService;
+
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocuments);
+		this._modelIsSynced = {};
+
+		this._toDispose = [];
+		this._toDispose.push(documentsAndEditors.onDocumentAdd(models => models.forEach(this._onModelAdded, this)));
+		this._toDispose.push(documentsAndEditors.onDocumentRemove(urls => urls.forEach(this._onModelRemoved, this)));
+		this._toDispose.push(this._modelReferenceCollection);
+		this._toDispose.push(modelService.onModelModeChanged(this._onModelModeChanged, this));
+
+		this._toDispose.push(textFileService.models.onModelSaved(e => {
+			if (this._shouldHandleFileEvent(e)) {
+				this._proxy.$acceptModelSaved(e.resource);
+			}
+		}));
+		this._toDispose.push(textFileService.models.onModelReverted(e => {
+			if (this._shouldHandleFileEvent(e)) {
+				this._proxy.$acceptDirtyStateChanged(e.resource, false);
+			}
+		}));
+		this._toDispose.push(textFileService.models.onModelDirty(e => {
+			if (this._shouldHandleFileEvent(e)) {
+				this._proxy.$acceptDirtyStateChanged(e.resource, true);
+			}
+		}));
+
+		this._modelToDisposeMap = Object.create(null);
+	}
+
+	public dispose(): void {
+		Object.keys(this._modelToDisposeMap).forEach((modelUrl) => {
+			this._modelToDisposeMap[modelUrl].dispose();
+		});
+		this._modelToDisposeMap = Object.create(null);
+		this._toDispose = dispose(this._toDispose);
+	}
+
+	private _shouldHandleFileEvent(e: TextFileModelChangeEvent): boolean {
+		const model = this._modelService.getModel(e.resource);
+		return !!model && shouldSynchronizeModel(model);
+	}
+
+	private _onModelAdded(model: ITextModel): void {
+		// Same filter as in mainThreadEditorsTracker
+		if (!shouldSynchronizeModel(model)) {
+			// don't synchronize too large models
+			return;
+		}
+		const modelUrl = model.uri;
+		this._modelIsSynced[modelUrl.toString()] = true;
+		this._modelToDisposeMap[modelUrl.toString()] = model.onDidChangeContent((e) => {
+			this._proxy.$acceptModelChanged(modelUrl, e, this._textFileService.isDirty(modelUrl));
+		});
+	}
+
+	private _onModelModeChanged(event: { model: ITextModel; oldModeId: string; }): void {
+		let { model, oldModeId } = event;
+		const modelUrl = model.uri;
+		if (!this._modelIsSynced[modelUrl.toString()]) {
+			return;
+		}
+		this._proxy.$acceptModelModeChanged(model.uri, oldModeId, model.getLanguageIdentifier().language);
+	}
+
+	private _onModelRemoved(modelUrl: URI): void {
+		const strModelUrl = modelUrl.toString();
+		if (!this._modelIsSynced[strModelUrl]) {
+			return;
+		}
+		delete this._modelIsSynced[strModelUrl];
+		this._modelToDisposeMap[strModelUrl].dispose();
+		delete this._modelToDisposeMap[strModelUrl];
+	}
+
+	// --- from extension host process
+
+	$trySaveDocument(uri: UriComponents): Promise<boolean> {
+		return this._textFileService.save(URI.revive(uri));
+	}
+
+	$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: Promise<boolean>;
+		switch (uri.scheme) {
+			case Schemas.untitled:
+				promise = this._handleUntitledScheme(uri);
+				break;
+			case Schemas.file:
+			default:
+				promise = this._handleAsResourceInput(uri);
+				break;
+		}
+
+		return promise.then(success => {
+			if (!success) {
+				return Promise.reject(new Error('cannot open ' + uri.toString()));
+			} else if (!this._modelIsSynced[uri.toString()]) {
+				return Promise.reject(new Error('cannot open ' + uri.toString() + '. Detail: Files above 50MB cannot be synchronized with extensions.'));
+			} else {
+				return undefined;
+			}
+		}, err => {
+			return Promise.reject(new Error('cannot open ' + uri.toString() + '. Detail: ' + toErrorMessage(err)));
+		});
+	}
+
+	$tryCreateDocument(options?: { language?: string, content?: string }): Promise<URI> {
+		return this._doCreateUntitled(undefined, options ? options.language : undefined, options ? options.content : undefined);
+	}
+
+	private _handleAsResourceInput(uri: URI): Promise<boolean> {
+		return this._textModelResolverService.createModelReference(uri).then(ref => {
+			this._modelReferenceCollection.add(ref);
+			const result = !!ref.object;
+			return result;
+		});
+	}
+
+	private _handleUntitledScheme(uri: URI): Promise<boolean> {
+		const asFileUri = uri.with({ scheme: Schemas.file });
+		return this._fileService.resolveFile(asFileUri).then(stats => {
+			// don't create a new file ontop of an existing file
+			return Promise.reject(new Error('file already exists on disk'));
+		}, err => {
+			return this._doCreateUntitled(uri).then(resource => !!resource);
+		});
+	}
+
+	private _doCreateUntitled(resource?: URI, modeId?: string, initialValue?: string): Promise<URI> {
+		return this._untitledEditorService.loadOrCreate({
+			resource,
+			modeId,
+			initialValue,
+			useResourcePath: Boolean(resource && resource.path)
+		}).then(model => {
+			const resource = model.getResource();
+
+			if (!this._modelIsSynced[resource.toString()]) {
+				throw new Error(`expected URI ${resource.toString()} to have come to LIFE`);
+			}
+
+			this._proxy.$acceptDirtyStateChanged(resource, true); // mark as dirty
+
+			return resource;
+		});
+	}
+}

src/vs/workbench/api/browser/mainThreadDocumentsAndEditors.ts

@@ -0,0 +1,468 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from 'vs/base/common/event';
+import { IDisposable, combinedDisposable, dispose } from 'vs/base/common/lifecycle';
+import { values } from 'vs/base/common/map';
+import { URI } from 'vs/base/common/uri';
+import { ICodeEditor, isCodeEditor, isDiffEditor, IActiveCodeEditor } from 'vs/editor/browser/editorBrowser';
+import { IBulkEditService } from 'vs/editor/browser/services/bulkEditService';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { IEditor } from 'vs/editor/common/editorCommon';
+import { ITextModel } from 'vs/editor/common/model';
+import { IModeService } from 'vs/editor/common/services/modeService';
+import { IModelService, shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
+import { IFileService } from 'vs/platform/files/common/files';
+import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { MainThreadDocuments } from 'vs/workbench/api/browser/mainThreadDocuments';
+import { MainThreadTextEditor } from 'vs/workbench/api/browser/mainThreadEditor';
+import { MainThreadTextEditors } from 'vs/workbench/api/browser/mainThreadEditors';
+import { ExtHostContext, ExtHostDocumentsAndEditorsShape, IDocumentsAndEditorsDelta, IExtHostContext, IModelAddedData, ITextEditorAddData, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { EditorViewColumn, editorGroupToViewColumn } from 'vs/workbench/api/common/shared/editor';
+import { BaseTextEditor } from 'vs/workbench/browser/parts/editor/textEditor';
+import { IEditor as IWorkbenchEditor } from 'vs/workbench/common/editor';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
+import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
+import { IUntitledEditorService } from 'vs/workbench/services/untitled/common/untitledEditorService';
+
+namespace delta {
+
+	export function ofSets<T>(before: Set<T>, after: Set<T>): { removed: T[], added: T[] } {
+		const removed: T[] = [];
+		const added: T[] = [];
+		before.forEach(element => {
+			if (!after.has(element)) {
+				removed.push(element);
+			}
+		});
+		after.forEach(element => {
+			if (!before.has(element)) {
+				added.push(element);
+			}
+		});
+		return { removed, added };
+	}
+
+	export function ofMaps<K, V>(before: Map<K, V>, after: Map<K, V>): { removed: V[], added: V[] } {
+		const removed: V[] = [];
+		const added: V[] = [];
+		before.forEach((value, index) => {
+			if (!after.has(index)) {
+				removed.push(value);
+			}
+		});
+		after.forEach((value, index) => {
+			if (!before.has(index)) {
+				added.push(value);
+			}
+		});
+		return { removed, added };
+	}
+}
+
+class TextEditorSnapshot {
+
+	readonly id: string;
+
+	constructor(
+		readonly editor: IActiveCodeEditor,
+	) {
+		this.id = `${editor.getId()},${editor.getModel().id}`;
+	}
+}
+
+class DocumentAndEditorStateDelta {
+
+	readonly isEmpty: boolean;
+
+	constructor(
+		readonly removedDocuments: ITextModel[],
+		readonly addedDocuments: ITextModel[],
+		readonly removedEditors: TextEditorSnapshot[],
+		readonly addedEditors: TextEditorSnapshot[],
+		readonly oldActiveEditor: string | null | undefined,
+		readonly newActiveEditor: string | null | undefined,
+	) {
+		this.isEmpty = this.removedDocuments.length === 0
+			&& this.addedDocuments.length === 0
+			&& this.removedEditors.length === 0
+			&& this.addedEditors.length === 0
+			&& oldActiveEditor === newActiveEditor;
+	}
+
+	toString(): string {
+		let ret = 'DocumentAndEditorStateDelta\n';
+		ret += `\tRemoved Documents: [${this.removedDocuments.map(d => d.uri.toString(true)).join(', ')}]\n`;
+		ret += `\tAdded Documents: [${this.addedDocuments.map(d => d.uri.toString(true)).join(', ')}]\n`;
+		ret += `\tRemoved Editors: [${this.removedEditors.map(e => e.id).join(', ')}]\n`;
+		ret += `\tAdded Editors: [${this.addedEditors.map(e => e.id).join(', ')}]\n`;
+		ret += `\tNew Active Editor: ${this.newActiveEditor}\n`;
+		return ret;
+	}
+}
+
+class DocumentAndEditorState {
+
+	static compute(before: DocumentAndEditorState, after: DocumentAndEditorState): DocumentAndEditorStateDelta {
+		if (!before) {
+			return new DocumentAndEditorStateDelta(
+				[], values(after.documents),
+				[], values(after.textEditors),
+				undefined, after.activeEditor
+			);
+		}
+		const documentDelta = delta.ofSets(before.documents, after.documents);
+		const editorDelta = delta.ofMaps(before.textEditors, after.textEditors);
+		const oldActiveEditor = before.activeEditor !== after.activeEditor ? before.activeEditor : undefined;
+		const newActiveEditor = before.activeEditor !== after.activeEditor ? after.activeEditor : undefined;
+
+		return new DocumentAndEditorStateDelta(
+			documentDelta.removed, documentDelta.added,
+			editorDelta.removed, editorDelta.added,
+			oldActiveEditor, newActiveEditor
+		);
+	}
+
+	constructor(
+		readonly documents: Set<ITextModel>,
+		readonly textEditors: Map<string, TextEditorSnapshot>,
+		readonly activeEditor: string | null | undefined,
+	) {
+		//
+	}
+}
+
+const enum ActiveEditorOrder {
+	Editor, Panel
+}
+
+class MainThreadDocumentAndEditorStateComputer {
+
+	private _toDispose: IDisposable[] = [];
+	private _toDisposeOnEditorRemove = new Map<string, IDisposable>();
+	private _currentState: DocumentAndEditorState;
+	private _activeEditorOrder: ActiveEditorOrder = ActiveEditorOrder.Editor;
+
+	constructor(
+		private readonly _onDidChangeState: (delta: DocumentAndEditorStateDelta) => void,
+		@IModelService private readonly _modelService: IModelService,
+		@ICodeEditorService private readonly _codeEditorService: ICodeEditorService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@IPanelService private readonly _panelService: IPanelService
+	) {
+		this._modelService.onModelAdded(this._updateStateOnModelAdd, this, this._toDispose);
+		this._modelService.onModelRemoved(_ => this._updateState(), this, this._toDispose);
+		this._editorService.onDidActiveEditorChange(_ => this._updateState(), this, this._toDispose);
+
+		this._codeEditorService.onCodeEditorAdd(this._onDidAddEditor, this, this._toDispose);
+		this._codeEditorService.onCodeEditorRemove(this._onDidRemoveEditor, this, this._toDispose);
+		this._codeEditorService.listCodeEditors().forEach(this._onDidAddEditor, this);
+
+		this._panelService.onDidPanelOpen(_ => this._activeEditorOrder = ActiveEditorOrder.Panel, undefined, this._toDispose);
+		this._panelService.onDidPanelClose(_ => this._activeEditorOrder = ActiveEditorOrder.Editor, undefined, this._toDispose);
+		this._editorService.onDidVisibleEditorsChange(_ => this._activeEditorOrder = ActiveEditorOrder.Editor, undefined, this._toDispose);
+
+		this._updateState();
+	}
+
+	dispose(): void {
+		this._toDispose = dispose(this._toDispose);
+	}
+
+	private _onDidAddEditor(e: ICodeEditor): void {
+		this._toDisposeOnEditorRemove.set(e.getId(), combinedDisposable([
+			e.onDidChangeModel(() => this._updateState()),
+			e.onDidFocusEditorText(() => this._updateState()),
+			e.onDidFocusEditorWidget(() => this._updateState(e))
+		]));
+		this._updateState();
+	}
+
+	private _onDidRemoveEditor(e: ICodeEditor): void {
+		const sub = this._toDisposeOnEditorRemove.get(e.getId());
+		if (sub) {
+			this._toDisposeOnEditorRemove.delete(e.getId());
+			sub.dispose();
+			this._updateState();
+		}
+	}
+
+	private _updateStateOnModelAdd(model: ITextModel): void {
+		if (!shouldSynchronizeModel(model)) {
+			// ignore
+			return;
+		}
+
+		if (!this._currentState) {
+			// too early
+			this._updateState();
+			return;
+		}
+
+		// small (fast) delta
+		this._currentState = new DocumentAndEditorState(
+			this._currentState.documents.add(model),
+			this._currentState.textEditors,
+			this._currentState.activeEditor
+		);
+
+		this._onDidChangeState(new DocumentAndEditorStateDelta(
+			[], [model],
+			[], [],
+			undefined, undefined
+		));
+	}
+
+	private _updateState(widgetFocusCandidate?: ICodeEditor): void {
+
+		// models: ignore too large models
+		const models = new Set<ITextModel>();
+		for (const model of this._modelService.getModels()) {
+			if (shouldSynchronizeModel(model)) {
+				models.add(model);
+			}
+		}
+
+		// editor: only take those that have a not too large model
+		const editors = new Map<string, TextEditorSnapshot>();
+		let activeEditor: string | null = null; // Strict null work. This doesn't like being undefined!
+
+		for (const editor of this._codeEditorService.listCodeEditors()) {
+			if (editor.isSimpleWidget) {
+				continue;
+			}
+			const model = editor.getModel();
+			if (editor.hasModel() && model && shouldSynchronizeModel(model)
+				&& !model.isDisposed() // model disposed
+				&& Boolean(this._modelService.getModel(model.uri)) // model disposing, the flag didn't flip yet but the model service already removed it
+			) {
+				const apiEditor = new TextEditorSnapshot(editor);
+				editors.set(apiEditor.id, apiEditor);
+				if (editor.hasTextFocus() || (widgetFocusCandidate === editor && editor.hasWidgetFocus())) {
+					// text focus has priority, widget focus is tricky because multiple
+					// editors might claim widget focus at the same time. therefore we use a
+					// candidate (which is the editor that has raised an widget focus event)
+					// in addition to the widget focus check
+					activeEditor = apiEditor.id;
+				}
+			}
+		}
+
+		// active editor: if none of the previous editors had focus we try
+		// to match output panels or the active workbench editor with
+		// one of editor we have just computed
+		if (!activeEditor) {
+			let candidate: IEditor | undefined;
+			if (this._activeEditorOrder === ActiveEditorOrder.Editor) {
+				candidate = this._getActiveEditorFromEditorPart() || this._getActiveEditorFromPanel();
+			} else {
+				candidate = this._getActiveEditorFromPanel() || this._getActiveEditorFromEditorPart();
+			}
+
+			if (candidate) {
+				editors.forEach(snapshot => {
+					if (candidate === snapshot.editor) {
+						activeEditor = snapshot.id;
+					}
+				});
+			}
+		}
+
+		// compute new state and compare against old
+		const newState = new DocumentAndEditorState(models, editors, activeEditor);
+		const delta = DocumentAndEditorState.compute(this._currentState, newState);
+		if (!delta.isEmpty) {
+			this._currentState = newState;
+			this._onDidChangeState(delta);
+		}
+	}
+
+	private _getActiveEditorFromPanel(): IEditor | undefined {
+		const panel = this._panelService.getActivePanel();
+		if (panel instanceof BaseTextEditor && isCodeEditor(panel.getControl())) {
+			return panel.getControl();
+		} else {
+			return undefined;
+		}
+	}
+
+	private _getActiveEditorFromEditorPart(): IEditor | undefined {
+		let result = this._editorService.activeTextEditorWidget;
+		if (isDiffEditor(result)) {
+			result = result.getModifiedEditor();
+		}
+		return result;
+	}
+}
+
+@extHostCustomer
+export class MainThreadDocumentsAndEditors {
+
+	private _toDispose: IDisposable[];
+	private readonly _proxy: ExtHostDocumentsAndEditorsShape;
+	private readonly _stateComputer: MainThreadDocumentAndEditorStateComputer;
+	private _textEditors = <{ [id: string]: MainThreadTextEditor }>Object.create(null);
+
+	private _onTextEditorAdd = new Emitter<MainThreadTextEditor[]>();
+	private _onTextEditorRemove = new Emitter<string[]>();
+	private _onDocumentAdd = new Emitter<ITextModel[]>();
+	private _onDocumentRemove = new Emitter<URI[]>();
+
+	readonly onTextEditorAdd: Event<MainThreadTextEditor[]> = this._onTextEditorAdd.event;
+	readonly onTextEditorRemove: Event<string[]> = this._onTextEditorRemove.event;
+	readonly onDocumentAdd: Event<ITextModel[]> = this._onDocumentAdd.event;
+	readonly onDocumentRemove: Event<URI[]> = this._onDocumentRemove.event;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IModelService private readonly _modelService: IModelService,
+		@ITextFileService private readonly _textFileService: ITextFileService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@ICodeEditorService codeEditorService: ICodeEditorService,
+		@IModeService modeService: IModeService,
+		@IFileService fileService: IFileService,
+		@ITextModelService textModelResolverService: ITextModelService,
+		@IUntitledEditorService untitledEditorService: IUntitledEditorService,
+		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService,
+		@IBulkEditService bulkEditService: IBulkEditService,
+		@IPanelService panelService: IPanelService
+
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocumentsAndEditors);
+
+		const mainThreadDocuments = new MainThreadDocuments(this, extHostContext, this._modelService, modeService, this._textFileService, fileService, textModelResolverService, untitledEditorService);
+		extHostContext.set(MainContext.MainThreadDocuments, mainThreadDocuments);
+
+		const mainThreadTextEditors = new MainThreadTextEditors(this, extHostContext, codeEditorService, bulkEditService, this._editorService, this._editorGroupService);
+		extHostContext.set(MainContext.MainThreadTextEditors, mainThreadTextEditors);
+
+		// It is expected that the ctor of the state computer calls our `_onDelta`.
+		this._stateComputer = new MainThreadDocumentAndEditorStateComputer(delta => this._onDelta(delta), _modelService, codeEditorService, this._editorService, panelService);
+
+		this._toDispose = [
+			mainThreadDocuments,
+			mainThreadTextEditors,
+			this._stateComputer,
+			this._onTextEditorAdd,
+			this._onTextEditorRemove,
+			this._onDocumentAdd,
+			this._onDocumentRemove,
+		];
+	}
+
+	dispose(): void {
+		this._toDispose = dispose(this._toDispose);
+	}
+
+	private _onDelta(delta: DocumentAndEditorStateDelta): void {
+
+		let removedDocuments: URI[];
+		const removedEditors: string[] = [];
+		const addedEditors: MainThreadTextEditor[] = [];
+
+		// removed models
+		removedDocuments = delta.removedDocuments.map(m => m.uri);
+
+		// added editors
+		for (const apiEditor of delta.addedEditors) {
+			const mainThreadEditor = new MainThreadTextEditor(apiEditor.id, apiEditor.editor.getModel(),
+				apiEditor.editor, { onGainedFocus() { }, onLostFocus() { } }, this._modelService);
+
+			this._textEditors[apiEditor.id] = mainThreadEditor;
+			addedEditors.push(mainThreadEditor);
+		}
+
+		// removed editors
+		for (const { id } of delta.removedEditors) {
+			const mainThreadEditor = this._textEditors[id];
+			if (mainThreadEditor) {
+				mainThreadEditor.dispose();
+				delete this._textEditors[id];
+				removedEditors.push(id);
+			}
+		}
+
+		const extHostDelta: IDocumentsAndEditorsDelta = Object.create(null);
+		let empty = true;
+		if (delta.newActiveEditor !== undefined) {
+			empty = false;
+			extHostDelta.newActiveEditor = delta.newActiveEditor;
+		}
+		if (removedDocuments.length > 0) {
+			empty = false;
+			extHostDelta.removedDocuments = removedDocuments;
+		}
+		if (removedEditors.length > 0) {
+			empty = false;
+			extHostDelta.removedEditors = removedEditors;
+		}
+		if (delta.addedDocuments.length > 0) {
+			empty = false;
+			extHostDelta.addedDocuments = delta.addedDocuments.map(m => this._toModelAddData(m));
+		}
+		if (delta.addedEditors.length > 0) {
+			empty = false;
+			extHostDelta.addedEditors = addedEditors.map(e => this._toTextEditorAddData(e));
+		}
+
+		if (!empty) {
+			// first update ext host
+			this._proxy.$acceptDocumentsAndEditorsDelta(extHostDelta);
+			// second update dependent state listener
+			this._onDocumentRemove.fire(removedDocuments);
+			this._onDocumentAdd.fire(delta.addedDocuments);
+			this._onTextEditorRemove.fire(removedEditors);
+			this._onTextEditorAdd.fire(addedEditors);
+		}
+	}
+
+	private _toModelAddData(model: ITextModel): IModelAddedData {
+		return {
+			uri: model.uri,
+			versionId: model.getVersionId(),
+			lines: model.getLinesContent(),
+			EOL: model.getEOL(),
+			modeId: model.getLanguageIdentifier().language,
+			isDirty: this._textFileService.isDirty(model.uri)
+		};
+	}
+
+	private _toTextEditorAddData(textEditor: MainThreadTextEditor): ITextEditorAddData {
+		const props = textEditor.getProperties();
+		return {
+			id: textEditor.getId(),
+			documentUri: textEditor.getModel().uri,
+			options: props.options,
+			selections: props.selections,
+			visibleRanges: props.visibleRanges,
+			editorPosition: this._findEditorPosition(textEditor)
+		};
+	}
+
+	private _findEditorPosition(editor: MainThreadTextEditor): EditorViewColumn | undefined {
+		for (const workbenchEditor of this._editorService.visibleControls) {
+			if (editor.matches(workbenchEditor)) {
+				return editorGroupToViewColumn(this._editorGroupService, workbenchEditor.group);
+			}
+		}
+		return undefined;
+	}
+
+	findTextEditorIdFor(editor: IWorkbenchEditor): string | undefined {
+		for (const id in this._textEditors) {
+			if (this._textEditors[id].matches(editor)) {
+				return id;
+			}
+		}
+		return undefined;
+	}
+
+	getEditor(id: string): MainThreadTextEditor {
+		return this._textEditors[id];
+	}
+}

src/vs/workbench/api/browser/mainThreadEditor.ts

@@ -0,0 +1,493 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from 'vs/base/common/event';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
+import { RenderLineNumbersType, TextEditorCursorStyle, cursorStyleToString } from 'vs/editor/common/config/editorOptions';
+import { IRange, Range } from 'vs/editor/common/core/range';
+import { ISelection, Selection } from 'vs/editor/common/core/selection';
+import * as editorCommon from 'vs/editor/common/editorCommon';
+import { IIdentifiedSingleEditOperation, ISingleEditOperation, ITextModel, ITextModelUpdateOptions } from 'vs/editor/common/model';
+import { IModelService } from 'vs/editor/common/services/modelService';
+import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
+import { IApplyEditsOptions, IEditorPropertiesChangeData, IResolvedTextEditorConfiguration, ITextEditorConfigurationUpdate, IUndoStopOptions, TextEditorRevealType } from 'vs/workbench/api/common/extHost.protocol';
+import { IEditor } from 'vs/workbench/common/editor';
+import { withNullAsUndefined } from 'vs/base/common/types';
+
+export interface IFocusTracker {
+	onGainedFocus(): void;
+	onLostFocus(): void;
+}
+
+export class MainThreadTextEditorProperties {
+
+	public static readFromEditor(previousProperties: MainThreadTextEditorProperties | null, model: ITextModel, codeEditor: ICodeEditor | null): MainThreadTextEditorProperties {
+		const selections = MainThreadTextEditorProperties._readSelectionsFromCodeEditor(previousProperties, codeEditor);
+		const options = MainThreadTextEditorProperties._readOptionsFromCodeEditor(previousProperties, model, codeEditor);
+		const visibleRanges = MainThreadTextEditorProperties._readVisibleRangesFromCodeEditor(previousProperties, codeEditor);
+		return new MainThreadTextEditorProperties(selections, options, visibleRanges);
+	}
+
+	private static _readSelectionsFromCodeEditor(previousProperties: MainThreadTextEditorProperties | null, codeEditor: ICodeEditor | null): Selection[] {
+		let result: Selection[] | null = null;
+		if (codeEditor) {
+			result = codeEditor.getSelections();
+		}
+		if (!result && previousProperties) {
+			result = previousProperties.selections;
+		}
+		if (!result) {
+			result = [new Selection(1, 1, 1, 1)];
+		}
+		return result;
+	}
+
+	private static _readOptionsFromCodeEditor(previousProperties: MainThreadTextEditorProperties | null, model: ITextModel, codeEditor: ICodeEditor | null): IResolvedTextEditorConfiguration {
+		if (model.isDisposed()) {
+			if (previousProperties) {
+				// shutdown time
+				return previousProperties.options;
+			} else {
+				throw new Error('No valid properties');
+			}
+		}
+
+		let cursorStyle: TextEditorCursorStyle;
+		let lineNumbers: RenderLineNumbersType;
+		if (codeEditor) {
+			const codeEditorOpts = codeEditor.getConfiguration();
+			cursorStyle = codeEditorOpts.viewInfo.cursorStyle;
+			lineNumbers = codeEditorOpts.viewInfo.renderLineNumbers;
+		} else if (previousProperties) {
+			cursorStyle = previousProperties.options.cursorStyle;
+			lineNumbers = previousProperties.options.lineNumbers;
+		} else {
+			cursorStyle = TextEditorCursorStyle.Line;
+			lineNumbers = RenderLineNumbersType.On;
+		}
+
+		const modelOptions = model.getOptions();
+		return {
+			insertSpaces: modelOptions.insertSpaces,
+			tabSize: modelOptions.tabSize,
+			indentSize: modelOptions.indentSize,
+			cursorStyle: cursorStyle,
+			lineNumbers: lineNumbers
+		};
+	}
+
+	private static _readVisibleRangesFromCodeEditor(previousProperties: MainThreadTextEditorProperties | null, codeEditor: ICodeEditor | null): Range[] {
+		if (codeEditor) {
+			return codeEditor.getVisibleRanges();
+		}
+		return [];
+	}
+
+	constructor(
+		public readonly selections: Selection[],
+		public readonly options: IResolvedTextEditorConfiguration,
+		public readonly visibleRanges: Range[]
+	) {
+	}
+
+	public generateDelta(oldProps: MainThreadTextEditorProperties | null, selectionChangeSource: string | null): IEditorPropertiesChangeData | null {
+		const delta: IEditorPropertiesChangeData = {
+			options: null,
+			selections: null,
+			visibleRanges: null
+		};
+
+		if (!oldProps || !MainThreadTextEditorProperties._selectionsEqual(oldProps.selections, this.selections)) {
+			delta.selections = {
+				selections: this.selections,
+				source: withNullAsUndefined(selectionChangeSource)
+			};
+		}
+
+		if (!oldProps || !MainThreadTextEditorProperties._optionsEqual(oldProps.options, this.options)) {
+			delta.options = this.options;
+		}
+
+		if (!oldProps || !MainThreadTextEditorProperties._rangesEqual(oldProps.visibleRanges, this.visibleRanges)) {
+			delta.visibleRanges = this.visibleRanges;
+		}
+
+		if (delta.selections || delta.options || delta.visibleRanges) {
+			// something changed
+			return delta;
+		}
+		// nothing changed
+		return null;
+	}
+
+	private static _selectionsEqual(a: Selection[], b: Selection[]): boolean {
+		if (a.length !== b.length) {
+			return false;
+		}
+		for (let i = 0; i < a.length; i++) {
+			if (!a[i].equalsSelection(b[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static _rangesEqual(a: Range[], b: Range[]): boolean {
+		if (a.length !== b.length) {
+			return false;
+		}
+		for (let i = 0; i < a.length; i++) {
+			if (!a[i].equalsRange(b[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static _optionsEqual(a: IResolvedTextEditorConfiguration, b: IResolvedTextEditorConfiguration): boolean {
+		if (a && !b || !a && b) {
+			return false;
+		}
+		if (!a && !b) {
+			return true;
+		}
+		return (
+			a.tabSize === b.tabSize
+			&& a.indentSize === b.indentSize
+			&& a.insertSpaces === b.insertSpaces
+			&& a.cursorStyle === b.cursorStyle
+			&& a.lineNumbers === b.lineNumbers
+		);
+	}
+}
+
+/**
+ * Text Editor that is permanently bound to the same model.
+ * It can be bound or not to a CodeEditor.
+ */
+export class MainThreadTextEditor {
+
+	private readonly _id: string;
+	private _model: ITextModel;
+	private readonly _modelService: IModelService;
+	private _modelListeners: IDisposable[];
+	private _codeEditor: ICodeEditor | null;
+	private readonly _focusTracker: IFocusTracker;
+	private _codeEditorListeners: IDisposable[];
+
+	private _properties: MainThreadTextEditorProperties;
+	private readonly _onPropertiesChanged: Emitter<IEditorPropertiesChangeData>;
+
+	constructor(
+		id: string,
+		model: ITextModel,
+		codeEditor: ICodeEditor,
+		focusTracker: IFocusTracker,
+		modelService: IModelService
+	) {
+		this._id = id;
+		this._model = model;
+		this._codeEditor = null;
+		this._focusTracker = focusTracker;
+		this._modelService = modelService;
+		this._codeEditorListeners = [];
+
+		this._onPropertiesChanged = new Emitter<IEditorPropertiesChangeData>();
+
+		this._modelListeners = [];
+		this._modelListeners.push(this._model.onDidChangeOptions((e) => {
+			this._updatePropertiesNow(null);
+		}));
+
+		this.setCodeEditor(codeEditor);
+		this._updatePropertiesNow(null);
+	}
+
+	public dispose(): void {
+		this._model = null!;
+		this._modelListeners = dispose(this._modelListeners);
+		this._codeEditor = null;
+		this._codeEditorListeners = dispose(this._codeEditorListeners);
+	}
+
+	private _updatePropertiesNow(selectionChangeSource: string | null): void {
+		this._setProperties(
+			MainThreadTextEditorProperties.readFromEditor(this._properties, this._model, this._codeEditor),
+			selectionChangeSource
+		);
+	}
+
+	private _setProperties(newProperties: MainThreadTextEditorProperties, selectionChangeSource: string | null): void {
+		const delta = newProperties.generateDelta(this._properties, selectionChangeSource);
+		this._properties = newProperties;
+		if (delta) {
+			this._onPropertiesChanged.fire(delta);
+		}
+	}
+
+	public getId(): string {
+		return this._id;
+	}
+
+	public getModel(): ITextModel {
+		return this._model;
+	}
+
+	public getCodeEditor(): ICodeEditor | null {
+		return this._codeEditor;
+	}
+
+	public hasCodeEditor(codeEditor: ICodeEditor | null): boolean {
+		return (this._codeEditor === codeEditor);
+	}
+
+	public setCodeEditor(codeEditor: ICodeEditor | null): void {
+		if (this.hasCodeEditor(codeEditor)) {
+			// Nothing to do...
+			return;
+		}
+		this._codeEditorListeners = dispose(this._codeEditorListeners);
+
+		this._codeEditor = codeEditor;
+		if (this._codeEditor) {
+
+			// Catch early the case that this code editor gets a different model set and disassociate from this model
+			this._codeEditorListeners.push(this._codeEditor.onDidChangeModel(() => {
+				this.setCodeEditor(null);
+			}));
+
+			this._codeEditorListeners.push(this._codeEditor.onDidFocusEditorWidget(() => {
+				this._focusTracker.onGainedFocus();
+			}));
+			this._codeEditorListeners.push(this._codeEditor.onDidBlurEditorWidget(() => {
+				this._focusTracker.onLostFocus();
+			}));
+
+			this._codeEditorListeners.push(this._codeEditor.onDidChangeCursorSelection((e) => {
+				// selection
+				this._updatePropertiesNow(e.source);
+			}));
+			this._codeEditorListeners.push(this._codeEditor.onDidChangeConfiguration(() => {
+				// options
+				this._updatePropertiesNow(null);
+			}));
+			this._codeEditorListeners.push(this._codeEditor.onDidLayoutChange(() => {
+				// visibleRanges
+				this._updatePropertiesNow(null);
+			}));
+			this._codeEditorListeners.push(this._codeEditor.onDidScrollChange(() => {
+				// visibleRanges
+				this._updatePropertiesNow(null);
+			}));
+			this._updatePropertiesNow(null);
+		}
+	}
+
+	public isVisible(): boolean {
+		return !!this._codeEditor;
+	}
+
+	public getProperties(): MainThreadTextEditorProperties {
+		return this._properties;
+	}
+
+	public get onPropertiesChanged(): Event<IEditorPropertiesChangeData> {
+		return this._onPropertiesChanged.event;
+	}
+
+	public setSelections(selections: ISelection[]): void {
+		if (this._codeEditor) {
+			this._codeEditor.setSelections(selections);
+			return;
+		}
+
+		const newSelections = selections.map(Selection.liftSelection);
+		this._setProperties(
+			new MainThreadTextEditorProperties(newSelections, this._properties.options, this._properties.visibleRanges),
+			null
+		);
+	}
+
+	private _setIndentConfiguration(newConfiguration: ITextEditorConfigurationUpdate): void {
+		const creationOpts = this._modelService.getCreationOptions(this._model.getLanguageIdentifier().language, this._model.uri, this._model.isForSimpleWidget);
+
+		if (newConfiguration.tabSize === 'auto' || newConfiguration.insertSpaces === 'auto') {
+			// one of the options was set to 'auto' => detect indentation
+			let insertSpaces = creationOpts.insertSpaces;
+			let tabSize = creationOpts.tabSize;
+
+			if (newConfiguration.insertSpaces !== 'auto' && typeof newConfiguration.insertSpaces !== 'undefined') {
+				insertSpaces = newConfiguration.insertSpaces;
+			}
+
+			if (newConfiguration.tabSize !== 'auto' && typeof newConfiguration.tabSize !== 'undefined') {
+				tabSize = newConfiguration.tabSize;
+			}
+
+			this._model.detectIndentation(insertSpaces, tabSize);
+			return;
+		}
+
+		const newOpts: ITextModelUpdateOptions = {};
+		if (typeof newConfiguration.insertSpaces !== 'undefined') {
+			newOpts.insertSpaces = newConfiguration.insertSpaces;
+		}
+		if (typeof newConfiguration.tabSize !== 'undefined') {
+			newOpts.tabSize = newConfiguration.tabSize;
+		}
+		if (typeof newConfiguration.indentSize !== 'undefined') {
+			if (newConfiguration.indentSize === 'tabSize') {
+				newOpts.indentSize = newOpts.tabSize || creationOpts.tabSize;
+			} else {
+				newOpts.indentSize = newConfiguration.indentSize;
+			}
+		}
+		this._model.updateOptions(newOpts);
+	}
+
+	public setConfiguration(newConfiguration: ITextEditorConfigurationUpdate): void {
+		this._setIndentConfiguration(newConfiguration);
+
+		if (!this._codeEditor) {
+			return;
+		}
+
+		if (newConfiguration.cursorStyle) {
+			const newCursorStyle = cursorStyleToString(newConfiguration.cursorStyle);
+			this._codeEditor.updateOptions({
+				cursorStyle: newCursorStyle
+			});
+		}
+
+		if (typeof newConfiguration.lineNumbers !== 'undefined') {
+			let lineNumbers: 'on' | 'off' | 'relative';
+			switch (newConfiguration.lineNumbers) {
+				case RenderLineNumbersType.On:
+					lineNumbers = 'on';
+					break;
+				case RenderLineNumbersType.Relative:
+					lineNumbers = 'relative';
+					break;
+				default:
+					lineNumbers = 'off';
+			}
+			this._codeEditor.updateOptions({
+				lineNumbers: lineNumbers
+			});
+		}
+	}
+
+	public setDecorations(key: string, ranges: editorCommon.IDecorationOptions[]): void {
+		if (!this._codeEditor) {
+			return;
+		}
+		this._codeEditor.setDecorations(key, ranges);
+	}
+
+	public setDecorationsFast(key: string, _ranges: number[]): void {
+		if (!this._codeEditor) {
+			return;
+		}
+		const ranges: Range[] = [];
+		for (let i = 0, len = Math.floor(_ranges.length / 4); i < len; i++) {
+			ranges[i] = new Range(_ranges[4 * i], _ranges[4 * i + 1], _ranges[4 * i + 2], _ranges[4 * i + 3]);
+		}
+		this._codeEditor.setDecorationsFast(key, ranges);
+	}
+
+	public revealRange(range: IRange, revealType: TextEditorRevealType): void {
+		if (!this._codeEditor) {
+			return;
+		}
+		switch (revealType) {
+			case TextEditorRevealType.Default:
+				this._codeEditor.revealRange(range, editorCommon.ScrollType.Smooth);
+				break;
+			case TextEditorRevealType.InCenter:
+				this._codeEditor.revealRangeInCenter(range, editorCommon.ScrollType.Smooth);
+				break;
+			case TextEditorRevealType.InCenterIfOutsideViewport:
+				this._codeEditor.revealRangeInCenterIfOutsideViewport(range, editorCommon.ScrollType.Smooth);
+				break;
+			case TextEditorRevealType.AtTop:
+				this._codeEditor.revealRangeAtTop(range, editorCommon.ScrollType.Smooth);
+				break;
+			default:
+				console.warn(`Unknown revealType: ${revealType}`);
+				break;
+		}
+	}
+
+	public isFocused(): boolean {
+		if (this._codeEditor) {
+			return this._codeEditor.hasTextFocus();
+		}
+		return false;
+	}
+
+	public matches(editor: IEditor): boolean {
+		if (!editor) {
+			return false;
+		}
+		return editor.getControl() === this._codeEditor;
+	}
+
+	public applyEdits(versionIdCheck: number, edits: ISingleEditOperation[], opts: IApplyEditsOptions): boolean {
+		if (this._model.getVersionId() !== versionIdCheck) {
+			// throw new Error('Model has changed in the meantime!');
+			// model changed in the meantime
+			return false;
+		}
+
+		if (!this._codeEditor) {
+			// console.warn('applyEdits on invisible editor');
+			return false;
+		}
+
+		if (typeof opts.setEndOfLine !== 'undefined') {
+			this._model.pushEOL(opts.setEndOfLine);
+		}
+
+		const transformedEdits = edits.map((edit): IIdentifiedSingleEditOperation => {
+			return {
+				range: Range.lift(edit.range),
+				text: edit.text,
+				forceMoveMarkers: edit.forceMoveMarkers
+			};
+		});
+
+		if (opts.undoStopBefore) {
+			this._codeEditor.pushUndoStop();
+		}
+		this._codeEditor.executeEdits('MainThreadTextEditor', transformedEdits);
+		if (opts.undoStopAfter) {
+			this._codeEditor.pushUndoStop();
+		}
+		return true;
+	}
+
+	insertSnippet(template: string, ranges: IRange[], opts: IUndoStopOptions) {
+
+		if (!this._codeEditor) {
+			return false;
+		}
+
+		const snippetController = SnippetController2.get(this._codeEditor);
+
+		// // cancel previous snippet mode
+		// snippetController.leaveSnippet();
+
+		// set selection, focus editor
+		const selections = ranges.map(r => new Selection(r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn));
+		this._codeEditor.setSelections(selections);
+		this._codeEditor.focus();
+
+		// make modifications
+		snippetController.insert(template, 0, 0, opts.undoStopBefore, opts.undoStopAfter);
+
+		return true;
+	}
+}

src/vs/workbench/api/browser/mainThreadEditors.ts

@@ -0,0 +1,306 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { disposed } from 'vs/base/common/errors';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { equals as objectEquals } from 'vs/base/common/objects';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IBulkEditService } from 'vs/editor/browser/services/bulkEditService';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { IRange } from 'vs/editor/common/core/range';
+import { ISelection } from 'vs/editor/common/core/selection';
+import { IDecorationOptions, IDecorationRenderOptions, ILineChange } from 'vs/editor/common/editorCommon';
+import { ISingleEditOperation } from 'vs/editor/common/model';
+import { CommandsRegistry } from 'vs/platform/commands/common/commands';
+import { IEditorOptions, ITextEditorOptions } from 'vs/platform/editor/common/editor';
+import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { IOpenerService } from 'vs/platform/opener/common/opener';
+import { MainThreadDocumentsAndEditors } from 'vs/workbench/api/browser/mainThreadDocumentsAndEditors';
+import { MainThreadTextEditor } from 'vs/workbench/api/browser/mainThreadEditor';
+import { ExtHostContext, ExtHostEditorsShape, IApplyEditsOptions, IExtHostContext, ITextDocumentShowOptions, ITextEditorConfigurationUpdate, ITextEditorPositionData, IUndoStopOptions, MainThreadTextEditorsShape, TextEditorRevealType, WorkspaceEditDto, reviveWorkspaceEditDto } from 'vs/workbench/api/common/extHost.protocol';
+import { EditorViewColumn, editorGroupToViewColumn, viewColumnToEditorGroup } from 'vs/workbench/api/common/shared/editor';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+
+export class MainThreadTextEditors implements MainThreadTextEditorsShape {
+
+	private static INSTANCE_COUNT: number = 0;
+
+	private readonly _instanceId: string;
+	private readonly _proxy: ExtHostEditorsShape;
+	private readonly _documentsAndEditors: MainThreadDocumentsAndEditors;
+	private _toDispose: IDisposable[];
+	private _textEditorsListenersMap: { [editorId: string]: IDisposable[]; };
+	private _editorPositionData: ITextEditorPositionData | null;
+	private _registeredDecorationTypes: { [decorationType: string]: boolean; };
+
+	constructor(
+		documentsAndEditors: MainThreadDocumentsAndEditors,
+		extHostContext: IExtHostContext,
+		@ICodeEditorService private readonly _codeEditorService: ICodeEditorService,
+		@IBulkEditService private readonly _bulkEditService: IBulkEditService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService
+	) {
+		this._instanceId = String(++MainThreadTextEditors.INSTANCE_COUNT);
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostEditors);
+		this._documentsAndEditors = documentsAndEditors;
+		this._toDispose = [];
+		this._textEditorsListenersMap = Object.create(null);
+		this._editorPositionData = null;
+
+		this._toDispose.push(documentsAndEditors.onTextEditorAdd(editors => editors.forEach(this._onTextEditorAdd, this)));
+		this._toDispose.push(documentsAndEditors.onTextEditorRemove(editors => editors.forEach(this._onTextEditorRemove, this)));
+
+		this._toDispose.push(this._editorService.onDidVisibleEditorsChange(() => this._updateActiveAndVisibleTextEditors()));
+		this._toDispose.push(this._editorGroupService.onDidRemoveGroup(() => this._updateActiveAndVisibleTextEditors()));
+		this._toDispose.push(this._editorGroupService.onDidMoveGroup(() => this._updateActiveAndVisibleTextEditors()));
+
+		this._registeredDecorationTypes = Object.create(null);
+	}
+
+	public dispose(): void {
+		Object.keys(this._textEditorsListenersMap).forEach((editorId) => {
+			dispose(this._textEditorsListenersMap[editorId]);
+		});
+		this._textEditorsListenersMap = Object.create(null);
+		this._toDispose = dispose(this._toDispose);
+		for (let decorationType in this._registeredDecorationTypes) {
+			this._codeEditorService.removeDecorationType(decorationType);
+		}
+		this._registeredDecorationTypes = Object.create(null);
+	}
+
+	private _onTextEditorAdd(textEditor: MainThreadTextEditor): void {
+		const id = textEditor.getId();
+		const toDispose: IDisposable[] = [];
+		toDispose.push(textEditor.onPropertiesChanged((data) => {
+			this._proxy.$acceptEditorPropertiesChanged(id, data);
+		}));
+
+		this._textEditorsListenersMap[id] = toDispose;
+	}
+
+	private _onTextEditorRemove(id: string): void {
+		dispose(this._textEditorsListenersMap[id]);
+		delete this._textEditorsListenersMap[id];
+	}
+
+	private _updateActiveAndVisibleTextEditors(): void {
+
+		// editor columns
+		const editorPositionData = this._getTextEditorPositionData();
+		if (!objectEquals(this._editorPositionData, editorPositionData)) {
+			this._editorPositionData = editorPositionData;
+			this._proxy.$acceptEditorPositionData(this._editorPositionData);
+		}
+	}
+
+	private _getTextEditorPositionData(): ITextEditorPositionData {
+		const result: ITextEditorPositionData = Object.create(null);
+		for (let workbenchEditor of this._editorService.visibleControls) {
+			const id = this._documentsAndEditors.findTextEditorIdFor(workbenchEditor);
+			if (id) {
+				result[id] = editorGroupToViewColumn(this._editorGroupService, workbenchEditor.group);
+			}
+		}
+		return result;
+	}
+
+	// --- from extension host process
+
+	$tryShowTextDocument(resource: UriComponents, options: ITextDocumentShowOptions): Promise<string | undefined> {
+		const uri = URI.revive(resource);
+
+		const editorOptions: ITextEditorOptions = {
+			preserveFocus: options.preserveFocus,
+			pinned: options.pinned,
+			selection: options.selection
+		};
+
+		const input = {
+			resource: uri,
+			options: editorOptions
+		};
+
+		return this._editorService.openEditor(input, viewColumnToEditorGroup(this._editorGroupService, options.position)).then(editor => {
+			if (!editor) {
+				return undefined;
+			}
+			return this._documentsAndEditors.findTextEditorIdFor(editor);
+		});
+	}
+
+	$tryShowEditor(id: string, position?: EditorViewColumn): Promise<void> {
+		const mainThreadEditor = this._documentsAndEditors.getEditor(id);
+		if (mainThreadEditor) {
+			const model = mainThreadEditor.getModel();
+			return this._editorService.openEditor({
+				resource: model.uri,
+				options: { preserveFocus: false }
+			}, viewColumnToEditorGroup(this._editorGroupService, position)).then(() => { return; });
+		}
+		return Promise.resolve();
+	}
+
+	$tryHideEditor(id: string): Promise<void> {
+		const mainThreadEditor = this._documentsAndEditors.getEditor(id);
+		if (mainThreadEditor) {
+			const editors = this._editorService.visibleControls;
+			for (let editor of editors) {
+				if (mainThreadEditor.matches(editor)) {
+					return editor.group.closeEditor(editor.input).then(() => { return; });
+				}
+			}
+		}
+		return Promise.resolve();
+	}
+
+	$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(undefined);
+	}
+
+	$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(undefined);
+	}
+
+	$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(undefined);
+	}
+
+	$tryRevealRange(id: string, range: IRange, revealType: TextEditorRevealType): Promise<void> {
+		if (!this._documentsAndEditors.getEditor(id)) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		this._documentsAndEditors.getEditor(id).revealRange(range, revealType);
+		return Promise.resolve();
+	}
+
+	$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(undefined);
+	}
+
+	$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): 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): Promise<boolean> {
+		if (!this._documentsAndEditors.getEditor(id)) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		return Promise.resolve(this._documentsAndEditors.getEditor(id).insertSnippet(template, ranges, opts));
+	}
+
+	$registerTextEditorDecorationType(key: string, options: IDecorationRenderOptions): void {
+		key = `${this._instanceId}-${key}`;
+		this._registeredDecorationTypes[key] = true;
+		this._codeEditorService.registerDecorationType(key, options);
+	}
+
+	$removeTextEditorDecorationType(key: string): void {
+		key = `${this._instanceId}-${key}`;
+		delete this._registeredDecorationTypes[key];
+		this._codeEditorService.removeDecorationType(key);
+	}
+
+	$getDiffInformation(id: string): Promise<ILineChange[]> {
+		const editor = this._documentsAndEditors.getEditor(id);
+
+		if (!editor) {
+			return Promise.reject(new Error('No such TextEditor'));
+		}
+
+		const codeEditor = editor.getCodeEditor();
+		if (!codeEditor) {
+			return Promise.reject(new Error('No such CodeEditor'));
+		}
+
+		const codeEditorId = codeEditor.getId();
+		const diffEditors = this._codeEditorService.listDiffEditors();
+		const [diffEditor] = diffEditors.filter(d => d.getOriginalEditor().getId() === codeEditorId || d.getModifiedEditor().getId() === codeEditorId);
+
+		if (diffEditor) {
+			return Promise.resolve(diffEditor.getLineChanges() || []);
+		}
+
+		const dirtyDiffContribution = codeEditor.getContribution('editor.contrib.dirtydiff');
+
+		if (dirtyDiffContribution) {
+			return Promise.resolve((dirtyDiffContribution as any).getChanges());
+		}
+
+		return Promise.resolve([]);
+	}
+}
+
+// --- commands
+
+CommandsRegistry.registerCommand('_workbench.open', function (accessor: ServicesAccessor, args: [URI, IEditorOptions, EditorViewColumn, string?]) {
+	const editorService = accessor.get(IEditorService);
+	const editorGroupService = accessor.get(IEditorGroupsService);
+	const openerService = accessor.get(IOpenerService);
+
+	const [resource, options, position, label] = args;
+
+	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(_ => undefined);
+	}
+
+	if (resource && resource.scheme === 'command') {
+		// do not allow to execute commands from here
+		return Promise.resolve(undefined);
+
+	}
+	// finally, delegate to opener service
+	return openerService.open(resource).then(_ => undefined);
+});
+
+
+CommandsRegistry.registerCommand('_workbench.diff', function (accessor: ServicesAccessor, args: [URI, URI, string, string, IEditorOptions, EditorViewColumn]) {
+	const editorService = accessor.get(IEditorService);
+	const editorGroupService = accessor.get(IEditorGroupsService);
+
+	let [leftResource, rightResource, label, description, options, position] = args;
+
+	if (!options || typeof options !== 'object') {
+		options = {
+			preserveFocus: false
+		};
+	}
+
+	if (!label) {
+		label = localize('diffLeftRightLabel', "{0} ⟷ {1}", leftResource.toString(true), rightResource.toString(true));
+	}
+
+	return editorService.openEditor({ leftResource, rightResource, label, description, options }, viewColumnToEditorGroup(editorGroupService, position)).then(() => undefined);
+});

src/vs/workbench/api/browser/mainThreadExtensionService.ts

@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { SerializedError } from 'vs/base/common/errors';
+import Severity from 'vs/base/common/severity';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IExtHostContext, MainContext, MainThreadExtensionServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { IExtensionService, ExtensionActivationError } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { localize } from 'vs/nls';
+import { Action } from 'vs/base/common/actions';
+import { EnablementState } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IWindowService } from 'vs/platform/windows/common/windows';
+import { IExtensionsWorkbenchService, IExtension } from 'vs/workbench/contrib/extensions/common/extensions';
+import { CancellationToken } from 'vs/base/common/cancellation';
+
+@extHostNamedCustomer(MainContext.MainThreadExtensionService)
+export class MainThreadExtensionService implements MainThreadExtensionServiceShape {
+
+	private readonly _extensionService: IExtensionService;
+	private readonly _notificationService: INotificationService;
+	private readonly _extensionsWorkbenchService: IExtensionsWorkbenchService;
+	private readonly _windowService: IWindowService;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IExtensionService extensionService: IExtensionService,
+		@INotificationService notificationService: INotificationService,
+		@IExtensionsWorkbenchService extensionsWorkbenchService: IExtensionsWorkbenchService,
+		@IWindowService windowService: IWindowService
+	) {
+		this._extensionService = extensionService;
+		this._notificationService = notificationService;
+		this._extensionsWorkbenchService = extensionsWorkbenchService;
+		this._windowService = windowService;
+	}
+
+	public dispose(): void {
+	}
+
+	$activateExtension(extensionId: ExtensionIdentifier, activationEvent: string): Promise<void> {
+		return this._extensionService._activateById(extensionId, activationEvent);
+	}
+	$onWillActivateExtension(extensionId: ExtensionIdentifier): void {
+		this._extensionService._onWillActivateExtension(extensionId);
+	}
+	$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;
+		error.stack = data.stack;
+		this._extensionService._onExtensionRuntimeError(extensionId, error);
+		console.error(`[${extensionId}]${error.message}`);
+		console.error(error.stack);
+	}
+	async $onExtensionActivationError(extensionId: ExtensionIdentifier, activationError: ExtensionActivationError): Promise<void> {
+		if (typeof activationError === 'string') {
+			this._extensionService._logOrShowMessage(Severity.Error, activationError);
+		} else {
+			this._handleMissingDependency(extensionId, activationError.dependency);
+		}
+	}
+
+	private async _handleMissingDependency(extensionId: ExtensionIdentifier, missingDependency: string): Promise<void> {
+		const extension = await this._extensionService.getExtension(extensionId.value);
+		if (extension) {
+			const local = await this._extensionsWorkbenchService.queryLocal();
+			const installedDependency = local.filter(i => areSameExtensions(i.identifier, { id: missingDependency }))[0];
+			if (installedDependency) {
+				await this._handleMissingInstalledDependency(extension, installedDependency);
+			} else {
+				await this._handleMissingNotInstalledDependency(extension, missingDependency);
+			}
+		}
+	}
+
+	private async _handleMissingInstalledDependency(extension: IExtensionDescription, missingInstalledDependency: IExtension): Promise<void> {
+		const extName = extension.displayName || extension.name;
+		if (missingInstalledDependency.enablementState === EnablementState.Enabled || missingInstalledDependency.enablementState === EnablementState.WorkspaceEnabled) {
+			this._notificationService.notify({
+				severity: Severity.Error,
+				message: localize('reload window', "Cannot activate extension '{0}' because it depends on extension '{1}', which is not loaded. Would you like to reload the window to load the extension?", extName, missingInstalledDependency.displayName),
+				actions: {
+					primary: [new Action('reload', localize('reload', "Reload Window"), '', true, () => this._windowService.reloadWindow())]
+				}
+			});
+		} else {
+			this._notificationService.notify({
+				severity: Severity.Error,
+				message: localize('disabledDep', "Cannot activate extension '{0}' because it depends on extension '{1}', which is disabled. Would you like to enable the extension and reload the window?", extName, missingInstalledDependency.displayName),
+				actions: {
+					primary: [new Action('enable', localize('enable dep', "Enable and Reload"), '', true,
+						() => this._extensionsWorkbenchService.setEnablement([missingInstalledDependency], missingInstalledDependency.enablementState === EnablementState.Disabled ? EnablementState.Enabled : EnablementState.WorkspaceEnabled)
+							.then(() => this._windowService.reloadWindow(), e => this._notificationService.error(e)))]
+				}
+			});
+		}
+	}
+
+	private async _handleMissingNotInstalledDependency(extension: IExtensionDescription, missingDependency: string): Promise<void> {
+		const extName = extension.displayName || extension.name;
+		const dependencyExtension = (await this._extensionsWorkbenchService.queryGallery({ names: [missingDependency] }, CancellationToken.None)).firstPage[0];
+		if (dependencyExtension) {
+			this._notificationService.notify({
+				severity: Severity.Error,
+				message: localize('uninstalledDep', "Cannot activate extension '{0}' because it depends on extension '{1}', which is not installed. Would you like to install the extension and reload the window?", extName, dependencyExtension.displayName),
+				actions: {
+					primary: [new Action('install', localize('install missing dep', "Install and Reload"), '', true,
+						() => this._extensionsWorkbenchService.install(dependencyExtension)
+							.then(() => this._windowService.reloadWindow(), e => this._notificationService.error(e)))]
+				}
+			});
+		} else {
+			this._notificationService.error(localize('unknownDep', "Cannot activate extension '{0}' because it depends on an unknown extension '{1}'.", extName, missingDependency));
+		}
+	}
+
+	$onExtensionHostExit(code: number): void {
+		this._extensionService._onExtensionHostExit(code);
+	}
+}

src/vs/workbench/api/browser/mainThreadHeapService.ts

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ExtHostContext, IExtHostContext } from '../common/extHost.protocol';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IHeapService } from 'vs/workbench/services/heap/common/heap';
+
+@extHostCustomer
+export class MainThreadHeapService extends Disposable {
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IHeapService heapService: IHeapService,
+	) {
+		super();
+		const proxy = extHostContext.getProxy(ExtHostContext.ExtHostHeapService);
+		this._register(heapService.onGarbageCollection((ids) => {
+			// send to ext host
+			proxy.$onGarbageCollection(ids);
+		}));
+	}
+}

src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts

@@ -0,0 +1,567 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { Emitter } from 'vs/base/common/event';
+import { ITextModel, ISingleEditOperation } from 'vs/editor/common/model';
+import * as modes from 'vs/editor/common/modes';
+import * as search from 'vs/workbench/contrib/search/common/search';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { Position as EditorPosition } from 'vs/editor/common/core/position';
+import { Range as EditorRange } from 'vs/editor/common/core/range';
+import { ExtHostContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, MainContext, IExtHostContext, ISerializedLanguageConfiguration, ISerializedRegExp, ISerializedIndentationRule, ISerializedOnEnterRule, LocationDto, WorkspaceSymbolDto, CodeActionDto, reviveWorkspaceEditDto, ISerializedDocumentFilter, DefinitionLinkDto, ISerializedSignatureHelpProviderMetadata, CodeInsetDto, LinkDto, CallHierarchyDto } from '../common/extHost.protocol';
+import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
+import { LanguageConfiguration, IndentationRule, OnEnterRule } from 'vs/editor/common/modes/languageConfiguration';
+import { IModeService } from 'vs/editor/common/services/modeService';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { URI } from 'vs/base/common/uri';
+import { Selection } from 'vs/editor/common/core/selection';
+import * as codeInset from 'vs/workbench/contrib/codeinset/common/codeInset';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import * as callh from 'vs/workbench/contrib/callHierarchy/common/callHierarchy';
+import { IHeapService } from 'vs/workbench/services/heap/common/heap';
+
+@extHostNamedCustomer(MainContext.MainThreadLanguageFeatures)
+export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesShape {
+
+	private readonly _proxy: ExtHostLanguageFeaturesShape;
+	private readonly _heapService: IHeapService;
+	private readonly _modeService: IModeService;
+	private readonly _registrations: { [handle: number]: IDisposable; } = Object.create(null);
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IHeapService heapService: IHeapService,
+		@IModeService modeService: IModeService,
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostLanguageFeatures);
+		this._heapService = heapService;
+		this._modeService = modeService;
+	}
+
+	dispose(): void {
+		for (const key in this._registrations) {
+			this._registrations[key].dispose();
+		}
+	}
+
+	$unregister(handle: number): void {
+		const registration = this._registrations[handle];
+		if (registration) {
+			registration.dispose();
+			delete this._registrations[handle];
+		}
+	}
+
+	//#region --- revive functions
+
+	private static _reviveLocationDto(data: LocationDto): modes.Location;
+	private static _reviveLocationDto(data: LocationDto[]): modes.Location[];
+	private static _reviveLocationDto(data: LocationDto | LocationDto[]): modes.Location | modes.Location[] {
+		if (!data) {
+			return <modes.Location>data;
+		} else if (Array.isArray(data)) {
+			data.forEach(l => MainThreadLanguageFeatures._reviveLocationDto(l));
+			return <modes.Location[]>data;
+		} else {
+			data.uri = URI.revive(data.uri);
+			return <modes.Location>data;
+		}
+	}
+
+	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.LocationLink>data;
+		} else if (Array.isArray(data)) {
+			data.forEach(l => MainThreadLanguageFeatures._reviveLocationLinkDto(l));
+			return <modes.LocationLink[]>data;
+		} else {
+			data.uri = URI.revive(data.uri);
+			return <modes.LocationLink>data;
+		}
+	}
+
+	private static _reviveWorkspaceSymbolDto(data: WorkspaceSymbolDto): search.IWorkspaceSymbol;
+	private static _reviveWorkspaceSymbolDto(data: WorkspaceSymbolDto[]): search.IWorkspaceSymbol[];
+	private static _reviveWorkspaceSymbolDto(data: undefined): undefined;
+	private static _reviveWorkspaceSymbolDto(data: WorkspaceSymbolDto | WorkspaceSymbolDto[] | undefined): search.IWorkspaceSymbol | search.IWorkspaceSymbol[] | undefined {
+		if (!data) {
+			return <undefined>data;
+		} else if (Array.isArray(data)) {
+			data.forEach(MainThreadLanguageFeatures._reviveWorkspaceSymbolDto);
+			return <search.IWorkspaceSymbol[]>data;
+		} else {
+			data.location = MainThreadLanguageFeatures._reviveLocationDto(data.location);
+			return <search.IWorkspaceSymbol>data;
+		}
+	}
+
+	private static _reviveCodeActionDto(data: CodeActionDto[] | undefined): modes.CodeAction[] {
+		if (data) {
+			data.forEach(code => reviveWorkspaceEditDto(code.edit));
+		}
+		return <modes.CodeAction[]>data;
+	}
+
+	private static _reviveLinkDTO(data: LinkDto): modes.ILink {
+		if (data.url && typeof data.url !== 'string') {
+			data.url = URI.revive(data.url);
+		}
+		return <modes.ILink>data;
+	}
+
+	private static _reviveCallHierarchyItemDto(data: CallHierarchyDto | undefined): callh.CallHierarchyItem {
+		if (data) {
+			data.uri = URI.revive(data.uri);
+		}
+		return data as callh.CallHierarchyItem;
+	}
+
+	//#endregion
+
+	// --- outline
+
+	$registerDocumentSymbolProvider(handle: number, selector: ISerializedDocumentFilter[], displayName: string): void {
+		this._registrations[handle] = modes.DocumentSymbolProviderRegistry.register(selector, <modes.DocumentSymbolProvider>{
+			displayName,
+			provideDocumentSymbols: (model: ITextModel, token: CancellationToken): Promise<modes.DocumentSymbol[] | undefined> => {
+				return this._proxy.$provideDocumentSymbols(handle, model.uri, token);
+			}
+		});
+	}
+
+	// --- code lens
+
+	$registerCodeLensSupport(handle: number, selector: ISerializedDocumentFilter[], eventHandle: number | undefined): void {
+
+		const provider = <modes.CodeLensProvider>{
+			provideCodeLenses: (model: ITextModel, token: CancellationToken): modes.ICodeLensSymbol[] | Promise<modes.ICodeLensSymbol[]> => {
+				return this._proxy.$provideCodeLenses(handle, model.uri, token).then(dto => {
+					if (dto) {
+						dto.forEach(obj => {
+							this._heapService.trackObject(obj);
+							this._heapService.trackObject(obj.command);
+						});
+					}
+					return dto;
+				});
+			},
+			resolveCodeLens: (model: ITextModel, codeLens: modes.ICodeLensSymbol, token: CancellationToken): Promise<modes.ICodeLensSymbol | undefined> => {
+				return this._proxy.$resolveCodeLens(handle, model.uri, codeLens, token).then(obj => {
+					if (obj) {
+						this._heapService.trackObject(obj);
+						this._heapService.trackObject(obj.command);
+					}
+					return obj;
+				});
+			}
+		};
+
+		if (typeof eventHandle === 'number') {
+			const emitter = new Emitter<modes.CodeLensProvider>();
+			this._registrations[eventHandle] = emitter;
+			provider.onDidChange = emitter.event;
+		}
+
+		this._registrations[handle] = modes.CodeLensProviderRegistry.register(selector, provider);
+	}
+
+	$emitCodeLensEvent(eventHandle: number, event?: any): void {
+		const obj = this._registrations[eventHandle];
+		if (obj instanceof Emitter) {
+			obj.fire(event);
+		}
+	}
+
+	// -- code inset
+
+	$registerCodeInsetSupport(handle: number, selector: ISerializedDocumentFilter[], eventHandle: number): void {
+
+		const provider = <codeInset.CodeInsetProvider>{
+			provideCodeInsets: (model: ITextModel, token: CancellationToken): CodeInsetDto[] | Thenable<CodeInsetDto[]> => {
+				return this._proxy.$provideCodeInsets(handle, model.uri, token).then(dto => {
+					if (dto) { dto.forEach(obj => this._heapService.trackObject(obj)); }
+					return dto;
+				});
+			},
+			resolveCodeInset: (model: ITextModel, codeInset: CodeInsetDto, token: CancellationToken): CodeInsetDto | Thenable<CodeInsetDto> => {
+				return this._proxy.$resolveCodeInset(handle, model.uri, codeInset, token).then(obj => {
+					this._heapService.trackObject(obj);
+					return obj;
+				});
+			}
+		};
+
+		if (typeof eventHandle === 'number') {
+			const emitter = new Emitter<codeInset.CodeInsetProvider>();
+			this._registrations[eventHandle] = emitter;
+			provider.onDidChange = emitter.event;
+		}
+
+		const langSelector = selector;
+		this._registrations[handle] = codeInset.CodeInsetProviderRegistry.register(langSelector, provider);
+	}
+
+	// --- declaration
+
+	$registerDefinitionSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = modes.DefinitionProviderRegistry.register(selector, <modes.DefinitionProvider>{
+			provideDefinition: (model, position, token): Promise<modes.LocationLink[]> => {
+				return this._proxy.$provideDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
+			}
+		});
+	}
+
+	$registerDeclarationSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = modes.DeclarationProviderRegistry.register(selector, <modes.DeclarationProvider>{
+			provideDeclaration: (model, position, token) => {
+				return this._proxy.$provideDeclaration(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
+			}
+		});
+	}
+
+	$registerImplementationSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = modes.ImplementationProviderRegistry.register(selector, <modes.ImplementationProvider>{
+			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(selector, <modes.TypeDefinitionProvider>{
+			provideTypeDefinition: (model, position, token): Promise<modes.LocationLink[]> => {
+				return this._proxy.$provideTypeDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
+			}
+		});
+	}
+
+	// --- extra info
+
+	$registerHoverProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = modes.HoverProviderRegistry.register(selector, <modes.HoverProvider>{
+			provideHover: (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.Hover | undefined> => {
+				return this._proxy.$provideHover(handle, model.uri, position, token);
+			}
+		});
+	}
+
+	// --- occurrences
+
+	$registerDocumentHighlightProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = modes.DocumentHighlightProviderRegistry.register(selector, <modes.DocumentHighlightProvider>{
+			provideDocumentHighlights: (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.DocumentHighlight[] | undefined> => {
+				return this._proxy.$provideDocumentHighlights(handle, model.uri, position, token);
+			}
+		});
+	}
+
+	// --- references
+
+	$registerReferenceSupport(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = modes.ReferenceProviderRegistry.register(selector, <modes.ReferenceProvider>{
+			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);
+			}
+		});
+	}
+
+	// --- quick fix
+
+	$registerQuickFixSupport(handle: number, selector: ISerializedDocumentFilter[], providedCodeActionKinds?: string[]): void {
+		this._registrations[handle] = modes.CodeActionProviderRegistry.register(selector, <modes.CodeActionProvider>{
+			provideCodeActions: (model: ITextModel, rangeOrSelection: EditorRange | Selection, context: modes.CodeActionContext, token: CancellationToken): Promise<modes.CodeAction[]> => {
+				return this._proxy.$provideCodeActions(handle, model.uri, rangeOrSelection, context, token).then(dto => {
+					if (dto) {
+						dto.forEach(obj => { this._heapService.trackObject(obj.command); });
+					}
+					return MainThreadLanguageFeatures._reviveCodeActionDto(dto);
+				});
+			},
+			providedCodeActionKinds
+		});
+	}
+
+	// --- formatting
+
+	$registerDocumentFormattingSupport(handle: number, selector: ISerializedDocumentFilter[], extensionId: ExtensionIdentifier): void {
+		this._registrations[handle] = modes.DocumentFormattingEditProviderRegistry.register(selector, <modes.DocumentFormattingEditProvider>{
+			extensionId,
+			provideDocumentFormattingEdits: (model: ITextModel, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[] | undefined> => {
+				return this._proxy.$provideDocumentFormattingEdits(handle, model.uri, options, token);
+			}
+		});
+	}
+
+	$registerRangeFormattingSupport(handle: number, selector: ISerializedDocumentFilter[], extensionId: ExtensionIdentifier): void {
+		this._registrations[handle] = modes.DocumentRangeFormattingEditProviderRegistry.register(selector, <modes.DocumentRangeFormattingEditProvider>{
+			extensionId,
+			provideDocumentRangeFormattingEdits: (model: ITextModel, range: EditorRange, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[] | undefined> => {
+				return this._proxy.$provideDocumentRangeFormattingEdits(handle, model.uri, range, options, token);
+			}
+		});
+	}
+
+	$registerOnTypeFormattingSupport(handle: number, selector: ISerializedDocumentFilter[], autoFormatTriggerCharacters: string[], extensionId: ExtensionIdentifier): void {
+		this._registrations[handle] = modes.OnTypeFormattingEditProviderRegistry.register(selector, <modes.OnTypeFormattingEditProvider>{
+			extensionId,
+			autoFormatTriggerCharacters,
+			provideOnTypeFormattingEdits: (model: ITextModel, position: EditorPosition, ch: string, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[] | undefined> => {
+				return this._proxy.$provideOnTypeFormattingEdits(handle, model.uri, position, ch, options, token);
+			}
+		});
+	}
+
+	// --- navigate type
+
+	$registerNavigateTypeSupport(handle: number): void {
+		let lastResultId: number | undefined;
+		this._registrations[handle] = search.WorkspaceSymbolProviderRegistry.register(<search.IWorkspaceSymbolProvider>{
+			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);
+					}
+					lastResultId = result._id;
+					return MainThreadLanguageFeatures._reviveWorkspaceSymbolDto(result.symbols);
+				});
+			},
+			resolveWorkspaceSymbol: (item: search.IWorkspaceSymbol, token: CancellationToken): Promise<search.IWorkspaceSymbol | undefined> => {
+				return this._proxy.$resolveWorkspaceSymbol(handle, item, token).then(i => {
+					if (i) {
+						return MainThreadLanguageFeatures._reviveWorkspaceSymbolDto(i);
+					}
+					return undefined;
+				});
+			}
+		});
+	}
+
+	// --- rename
+
+	$registerRenameSupport(handle: number, selector: ISerializedDocumentFilter[], supportResolveLocation: boolean): void {
+
+		this._registrations[handle] = modes.RenameProviderRegistry.register(selector, <modes.RenameProvider>{
+			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): Promise<modes.RenameLocation | undefined> => this._proxy.$resolveRenameLocation(handle, model.uri, position, token)
+				: undefined
+		});
+	}
+
+	// --- suggest
+
+	$registerSuggestSupport(handle: number, selector: ISerializedDocumentFilter[], triggerCharacters: string[], supportsResolveDetails: boolean): void {
+		this._registrations[handle] = modes.CompletionProviderRegistry.register(selector, <modes.CompletionItemProvider>{
+			triggerCharacters,
+			provideCompletionItems: (model: ITextModel, position: EditorPosition, context: modes.CompletionContext, token: CancellationToken): Promise<modes.CompletionList | undefined> => {
+				return this._proxy.$provideCompletionItems(handle, model.uri, position, context, token).then(result => {
+					if (!result) {
+						return result;
+					}
+					return {
+						suggestions: result.suggestions,
+						incomplete: result.incomplete,
+						dispose: () => {
+							if (typeof result._id === 'number') {
+								this._proxy.$releaseCompletionItems(handle, result._id);
+							}
+						}
+					};
+				});
+			},
+			resolveCompletionItem: supportsResolveDetails
+				? (model, position, suggestion, token) => this._proxy.$resolveCompletionItem(handle, model.uri, position, suggestion, token)
+				: undefined
+		});
+	}
+
+	// --- parameter hints
+
+	$registerSignatureHelpProvider(handle: number, selector: ISerializedDocumentFilter[], metadata: ISerializedSignatureHelpProviderMetadata): void {
+		this._registrations[handle] = modes.SignatureHelpProviderRegistry.register(selector, <modes.SignatureHelpProvider>{
+
+			signatureHelpTriggerCharacters: metadata.triggerCharacters,
+			signatureHelpRetriggerCharacters: metadata.retriggerCharacters,
+
+			provideSignatureHelp: (model: ITextModel, position: EditorPosition, token: CancellationToken, context: modes.SignatureHelpContext): Promise<modes.SignatureHelp | undefined> => {
+				return this._proxy.$provideSignatureHelp(handle, model.uri, position, context, token);
+			}
+		});
+	}
+
+	// --- links
+
+	$registerDocumentLinkProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = modes.LinkProviderRegistry.register(selector, <modes.LinkProvider>{
+			provideLinks: (model, token) => {
+				return this._proxy.$provideDocumentLinks(handle, model.uri, token).then(dto => {
+					if (dto) {
+						dto.forEach(obj => {
+							MainThreadLanguageFeatures._reviveLinkDTO(obj);
+							this._heapService.trackObject(obj);
+						});
+					}
+					return dto;
+				});
+			},
+			resolveLink: (link, token) => {
+				return this._proxy.$resolveDocumentLink(handle, link, token).then(obj => {
+					if (obj) {
+						MainThreadLanguageFeatures._reviveLinkDTO(obj);
+						this._heapService.trackObject(obj);
+					}
+					return obj;
+				});
+			}
+		});
+	}
+
+	// --- colors
+
+	$registerDocumentColorProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
+		const proxy = this._proxy;
+		this._registrations[handle] = modes.ColorProviderRegistry.register(selector, <modes.DocumentColorProvider>{
+			provideDocumentColors: (model, token) => {
+				return proxy.$provideDocumentColors(handle, model.uri, token)
+					.then(documentColors => {
+						return documentColors.map(documentColor => {
+							const [red, green, blue, alpha] = documentColor.color;
+							const color = {
+								red: red,
+								green: green,
+								blue: blue,
+								alpha
+							};
+
+							return {
+								color,
+								range: documentColor.range
+							};
+						});
+					});
+			},
+
+			provideColorPresentations: (model, colorInfo, token) => {
+				return proxy.$provideColorPresentations(handle, model.uri, {
+					color: [colorInfo.color.red, colorInfo.color.green, colorInfo.color.blue, colorInfo.color.alpha],
+					range: colorInfo.range
+				}, token);
+			}
+		});
+	}
+
+	// --- folding
+
+	$registerFoldingRangeProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
+		const proxy = this._proxy;
+		this._registrations[handle] = modes.FoldingRangeProviderRegistry.register(selector, <modes.FoldingRangeProvider>{
+			provideFoldingRanges: (model, context, token) => {
+				return proxy.$provideFoldingRanges(handle, model.uri, context, token);
+			}
+		});
+	}
+
+	// -- smart select
+
+	$registerSelectionRangeProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = modes.SelectionRangeRegistry.register(selector, {
+			provideSelectionRanges: (model, positions, token) => {
+				return this._proxy.$provideSelectionRanges(handle, model.uri, positions, token);
+			}
+		});
+	}
+
+	// --- call hierarchy
+
+	$registerCallHierarchyProvider(handle: number, selector: ISerializedDocumentFilter[]): void {
+		this._registrations[handle] = callh.CallHierarchyProviderRegistry.register(selector, {
+			provideCallHierarchyItem: (document, position, token) => {
+				return this._proxy.$provideCallHierarchyItem(handle, document.uri, position, token).then(MainThreadLanguageFeatures._reviveCallHierarchyItemDto);
+			},
+			resolveCallHierarchyItem: (item, direction, token) => {
+				return this._proxy.$resolveCallHierarchyItem(handle, item, direction, token).then(data => {
+					if (data) {
+						for (let i = 0; i < data.length; i++) {
+							const [item, locations] = data[i];
+							data[i] = [
+								MainThreadLanguageFeatures._reviveCallHierarchyItemDto(item),
+								MainThreadLanguageFeatures._reviveLocationDto(locations)
+							];
+						}
+					}
+					return data as [callh.CallHierarchyItem, modes.Location[]][];
+				});
+			}
+		});
+	}
+
+	// --- configuration
+
+	private static _reviveRegExp(regExp: ISerializedRegExp): RegExp {
+		return new RegExp(regExp.pattern, regExp.flags);
+	}
+
+	private static _reviveIndentationRule(indentationRule: ISerializedIndentationRule): IndentationRule {
+		return {
+			decreaseIndentPattern: MainThreadLanguageFeatures._reviveRegExp(indentationRule.decreaseIndentPattern),
+			increaseIndentPattern: MainThreadLanguageFeatures._reviveRegExp(indentationRule.increaseIndentPattern),
+			indentNextLinePattern: indentationRule.indentNextLinePattern ? MainThreadLanguageFeatures._reviveRegExp(indentationRule.indentNextLinePattern) : undefined,
+			unIndentedLinePattern: indentationRule.unIndentedLinePattern ? MainThreadLanguageFeatures._reviveRegExp(indentationRule.unIndentedLinePattern) : undefined,
+		};
+	}
+
+	private static _reviveOnEnterRule(onEnterRule: ISerializedOnEnterRule): OnEnterRule {
+		return {
+			beforeText: MainThreadLanguageFeatures._reviveRegExp(onEnterRule.beforeText),
+			afterText: onEnterRule.afterText ? MainThreadLanguageFeatures._reviveRegExp(onEnterRule.afterText) : undefined,
+			oneLineAboveText: onEnterRule.oneLineAboveText ? MainThreadLanguageFeatures._reviveRegExp(onEnterRule.oneLineAboveText) : undefined,
+			action: onEnterRule.action
+		};
+	}
+
+	private static _reviveOnEnterRules(onEnterRules: ISerializedOnEnterRule[]): OnEnterRule[] {
+		return onEnterRules.map(MainThreadLanguageFeatures._reviveOnEnterRule);
+	}
+
+	$setLanguageConfiguration(handle: number, languageId: string, _configuration: ISerializedLanguageConfiguration): void {
+
+		const configuration: LanguageConfiguration = {
+			comments: _configuration.comments,
+			brackets: _configuration.brackets,
+			wordPattern: _configuration.wordPattern ? MainThreadLanguageFeatures._reviveRegExp(_configuration.wordPattern) : undefined,
+			indentationRules: _configuration.indentationRules ? MainThreadLanguageFeatures._reviveIndentationRule(_configuration.indentationRules) : undefined,
+			onEnterRules: _configuration.onEnterRules ? MainThreadLanguageFeatures._reviveOnEnterRules(_configuration.onEnterRules) : undefined,
+
+			autoClosingPairs: undefined,
+			surroundingPairs: undefined,
+			__electricCharacterSupport: undefined
+		};
+
+		if (_configuration.__characterPairSupport) {
+			// backwards compatibility
+			configuration.autoClosingPairs = _configuration.__characterPairSupport.autoClosingPairs;
+		}
+
+		if (_configuration.__electricCharacterSupport && _configuration.__electricCharacterSupport.docComment) {
+			configuration.__electricCharacterSupport = {
+				docComment: {
+					open: _configuration.__electricCharacterSupport.docComment.open,
+					close: _configuration.__electricCharacterSupport.docComment.close
+				}
+			};
+		}
+
+		const languageIdentifier = this._modeService.getLanguageIdentifier(languageId);
+		if (languageIdentifier) {
+			this._registrations[handle] = LanguageConfigurationRegistry.register(languageIdentifier, configuration);
+		}
+	}
+
+}

src/vs/workbench/api/browser/mainThreadSaveParticipant.ts

@@ -263,7 +263,7 @@ class FormatOnSaveParticipant implements ISaveParticipantParticipant {
 
 		const timeout = this._configurationService.getValue<number>('editor.formatOnSaveTimeout', { overrideIdentifier: model.getLanguageIdentifier().language, resource: editorModel.getResource() });
 
-		return new Promise<TextEdit[] | null | undefined>((resolve, reject) => {
+		return new Promise<TextEdit[] | null>((resolve, reject) => {
 			const source = new CancellationTokenSource();
 			const request = getDocumentFormattingEdits(this._telemetryService, this._editorWorkerService, model, model.getFormattingOptions(), FormatMode.Auto, source.token);
 

src/vs/workbench/api/browser/mainThreadUrls.ts

@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ExtHostContext, IExtHostContext, MainContext, MainThreadUrlsShape, ExtHostUrlsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../common/extHostCustomers';
+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/common/inactiveExtensionUrlHandler';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+
+class ExtensionUrlHandler implements IURLHandler {
+
+	constructor(
+		private readonly proxy: ExtHostUrlsShape,
+		private readonly handle: number,
+		readonly extensionId: ExtensionIdentifier
+	) { }
+
+	handleURL(uri: URI): Promise<boolean> {
+		if (!ExtensionIdentifier.equals(this.extensionId, uri.authority)) {
+			return Promise.resolve(false);
+		}
+
+		return Promise.resolve(this.proxy.$handleExternalUri(this.handle, uri)).then(() => true);
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadUrls)
+export class MainThreadUrls implements MainThreadUrlsShape {
+
+	private readonly proxy: ExtHostUrlsShape;
+	private handlers = new Map<number, { extensionId: ExtensionIdentifier, disposable: IDisposable }>();
+
+	constructor(
+		context: IExtHostContext,
+		@IURLService private readonly urlService: IURLService,
+		@IExtensionUrlHandler private readonly inactiveExtensionUrlHandler: IExtensionUrlHandler
+	) {
+		this.proxy = context.getProxy(ExtHostContext.ExtHostUrls);
+	}
+
+	$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(undefined);
+	}
+
+	$unregisterUriHandler(handle: number): Promise<void> {
+		const tuple = this.handlers.get(handle);
+
+		if (!tuple) {
+			return Promise.resolve(undefined);
+		}
+
+		const { extensionId, disposable } = tuple;
+
+		this.inactiveExtensionUrlHandler.unregisterExtensionHandler(extensionId);
+		this.handlers.delete(handle);
+		disposable.dispose();
+
+		return Promise.resolve(undefined);
+	}
+
+	dispose(): void {
+		this.handlers.forEach(({ disposable }) => disposable.dispose());
+		this.handlers.clear();
+	}
+}