Merge branch 'master' into scm-api

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -10,8 +10,8 @@ import { score } from 'vs/editor/common/modes/languageSelector';
 import * as Platform from 'vs/base/common/platform';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import * as errors from 'vs/base/common/errors';
-import product from 'vs/platform/product';
-import pkg from 'vs/platform/package';
+import product from 'vs/platform/node/product';
+import pkg from 'vs/platform/node/package';
 import { ExtHostFileSystemEventService } from 'vs/workbench/api/node/extHostFileSystemEventService';
 import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
 import { ExtHostDocumentSaveParticipant } from 'vs/workbench/api/node/extHostDocumentSaveParticipant';
@@ -114,7 +114,7 @@ export function createApiFactory(initData: IInitData, threadService: IThreadServ
 	const extHostMessageService = new ExtHostMessageService(threadService);
 	const extHostStatusBar = new ExtHostStatusBar(threadService);
 	const extHostOutputService = new ExtHostOutputService(threadService);
-	const workspacePath = contextService.getWorkspace() ? contextService.getWorkspace().resource.fsPath : undefined;
+	const workspacePath = contextService.hasWorkspace() ? contextService.getWorkspace().resource.fsPath : undefined;
 	const extHostWorkspace = new ExtHostWorkspace(threadService, workspacePath);
 	const extHostLanguages = new ExtHostLanguages(threadService);
 
@@ -517,7 +517,7 @@ function createExtensionPathIndex(extensionService: ExtHostExtensionService): TP
 function defineAPI(factory: IExtensionApiFactory, extensionPaths: TrieMap<IExtensionDescription>): void {
 
 	// each extension is meant to get its own api implementation
-	const extApiImpl: { [id: string]: typeof vscode } = Object.create(null);
+	const extApiImpl = new Map<string, typeof vscode>();
 	let defaultApiImpl: typeof vscode;
 
 	const node_module = <any>require.__$__nodeRequire('module');
@@ -530,9 +530,10 @@ function defineAPI(factory: IExtensionApiFactory, extensionPaths: TrieMap<IExten
 		// get extension id from filename and api for extension
 		const ext = extensionPaths.findSubstr(parent.filename);
 		if (ext) {
-			let apiImpl = extApiImpl[ext.id];
+			let apiImpl = extApiImpl.get(ext.id);
 			if (!apiImpl) {
-				apiImpl = extApiImpl[ext.id] = factory(ext);
+				apiImpl = factory(ext);
+				extApiImpl.set(ext.id, apiImpl);
 			}
 			return apiImpl;
 		}

src/vs/workbench/api/node/extHost.protocol.ts

@@ -31,7 +31,7 @@ import { IResourceEdit } from 'vs/editor/common/services/bulkEdit';
 import { ConfigurationTarget } from 'vs/workbench/services/configuration/common/configurationEditing';
 import { IWorkspaceConfigurationValues } from 'vs/workbench/services/configuration/common/configuration';
 
-import { IPickOpenEntry, IPickOptions } from 'vs/workbench/services/quickopen/common/quickOpenService';
+import { IPickOpenEntry, IPickOptions } from 'vs/platform/quickOpen/common/quickOpen';
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import { IWorkspaceSymbol } from 'vs/workbench/parts/search/common/search';
 import { IApplyEditsOptions, TextEditorRevealType, ITextEditorConfigurationUpdate, IResolvedTextEditorConfiguration, ISelectionChangeEvent } from './mainThreadEditorsTracker';
@@ -150,7 +150,8 @@ export abstract class MainThreadErrorsShape {
 export abstract class MainThreadLanguageFeaturesShape {
 	$unregister(handle: number): TPromise<any> { throw ni(); }
 	$registerOutlineSupport(handle: number, selector: vscode.DocumentSelector): TPromise<any> { throw ni(); }
-	$registerCodeLensSupport(handle: number, selector: vscode.DocumentSelector): TPromise<any> { throw ni(); }
+	$registerCodeLensSupport(handle: number, selector: vscode.DocumentSelector, eventHandle: number): TPromise<any> { throw ni(); }
+	$emitCodeLensEvent(eventHandle: number, event?: any): TPromise<any> { throw ni(); }
 	$registerDeclaractionSupport(handle: number, selector: vscode.DocumentSelector): TPromise<any> { throw ni(); }
 	$registerHoverProvider(handle: number, selector: vscode.DocumentSelector): TPromise<any> { throw ni(); }
 	$registerDocumentHighlightProvider(handle: number, selector: vscode.DocumentSelector): TPromise<any> { throw ni(); }

src/vs/workbench/api/node/extHostCommands.ts

@@ -26,7 +26,7 @@ interface CommandHandler {
 
 export class ExtHostCommands extends ExtHostCommandsShape {
 
-	private _commands: { [n: string]: CommandHandler } = Object.create(null);
+	private _commands = new Map<string, CommandHandler>();
 	private _proxy: MainThreadCommandsShape;
 	private _extHostEditors: ExtHostEditors;
 	private _converter: CommandsConverter;
@@ -52,15 +52,15 @@ export class ExtHostCommands extends ExtHostCommandsShape {
 			throw new Error('invalid id');
 		}
 
-		if (this._commands[id]) {
+		if (this._commands.has(id)) {
 			throw new Error('command with id already exists');
 		}
 
-		this._commands[id] = { callback, thisArg, description };
+		this._commands.set(id, { callback, thisArg, description });
 		this._proxy.$registerCommand(id);
 
 		return new extHostTypes.Disposable(() => {
-			if (delete this._commands[id]) {
+			if (this._commands.delete(id)) {
 				this._proxy.$unregisterCommand(id);
 			}
 		});
@@ -68,7 +68,7 @@ export class ExtHostCommands extends ExtHostCommandsShape {
 
 	executeCommand<T>(id: string, ...args: any[]): Thenable<T> {
 
-		if (this._commands[id]) {
+		if (this._commands.has(id)) {
 			// we stay inside the extension host and support
 			// to pass any kind of parameters around
 			return this.$executeContributedCommand(id, ...args);
@@ -97,7 +97,7 @@ export class ExtHostCommands extends ExtHostCommandsShape {
 	}
 
 	$executeContributedCommand<T>(id: string, ...args: any[]): Thenable<T> {
-		let command = this._commands[id];
+		let command = this._commands.get(id);
 		if (!command) {
 			return TPromise.wrapError<T>(`Contributed command '${id}' does not exist.`);
 		}
@@ -139,12 +139,12 @@ export class ExtHostCommands extends ExtHostCommandsShape {
 
 	$getContributedCommandHandlerDescriptions(): TPromise<{ [id: string]: string | ICommandHandlerDescription }> {
 		const result: { [id: string]: string | ICommandHandlerDescription } = Object.create(null);
-		for (let id in this._commands) {
-			let {description} = this._commands[id];
+		this._commands.forEach((command, id) => {
+			let {description} = command;
 			if (description) {
 				result[id] = description;
 			}
-		}
+		});
 		return TPromise.as(result);
 	}
 }
@@ -212,4 +212,4 @@ export class CommandsConverter {
 		return this._commands.executeCommand(actualCmd.command, ...actualCmd.arguments);
 	}
 
-}
+}

src/vs/workbench/api/node/extHostConfiguration.ts

@@ -107,6 +107,6 @@ export class ExtHostConfiguration extends ExtHostConfigurationShape {
 			mixin(result, config, false);
 		}
 
-		return Object.freeze(result);
+		return <WorkspaceConfiguration>Object.freeze(result);
 	}
 }

src/vs/workbench/api/node/extHostDiagnostics.ts

@@ -15,13 +15,13 @@ import { DiagnosticSeverity } from './extHostTypes';
 
 export class DiagnosticCollection implements vscode.DiagnosticCollection {
 
-	private static _maxDiagnosticsPerFile: number = 250;
+	private static readonly _maxDiagnosticsPerFile: number = 250;
+
+	private readonly _name: string;
 
-	private _name: string;
 	private _proxy: MainThreadDiagnosticsShape;
-
 	private _isDisposed = false;
-	private _data: { [uri: string]: vscode.Diagnostic[] } = Object.create(null);
+	private _data = new Map<string, vscode.Diagnostic[]>();
 
 	constructor(name: string, proxy: MainThreadDiagnosticsShape) {
 		this._name = name;
@@ -66,7 +66,7 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 			}
 
 			// update single row
-			this._data[first.toString()] = diagnostics;
+			this._data.set(first.toString(), diagnostics);
 			toSync = [first];
 
 		} else if (Array.isArray(first)) {
@@ -83,19 +83,19 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 			for (const {tuple} of sortedTuples) {
 				const [uri, diagnostics] = tuple;
 				if (!lastUri || uri.toString() !== lastUri.toString()) {
-					if (lastUri && this._data[lastUri.toString()].length === 0) {
-						delete this._data[lastUri.toString()];
+					if (lastUri && this._data.get(lastUri.toString()).length === 0) {
+						this._data.delete(lastUri.toString());
 					}
 					lastUri = uri;
 					toSync.push(uri);
-					this._data[uri.toString()] = [];
+					this._data.set(uri.toString(), []);
 				}
 
 				if (!diagnostics) {
 					// [Uri, undefined] means clear this
-					this._data[uri.toString()].length = 0;
+					this._data.get(uri.toString()).length = 0;
 				} else {
-					this._data[uri.toString()].push(...diagnostics);
+					this._data.get(uri.toString()).push(...diagnostics);
 				}
 			}
 		}
@@ -104,7 +104,7 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 		const entries: [URI, IMarkerData[]][] = [];
 		for (let uri of toSync) {
 			let marker: IMarkerData[];
-			let diagnostics = this._data[uri.toString()];
+			let diagnostics = this._data.get(uri.toString());
 			if (diagnostics) {
 
 				// no more than 250 diagnostics per file
@@ -144,35 +144,35 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 
 	delete(uri: vscode.Uri): void {
 		this._checkDisposed();
-		delete this._data[uri.toString()];
+		this._data.delete(uri.toString());
 		this._proxy.$changeMany(this.name, [[<URI>uri, undefined]]);
 	}
 
 	clear(): void {
 		this._checkDisposed();
-		this._data = Object.create(null);
+		this._data.clear();
 		this._proxy.$clear(this.name);
 	}
 
 	forEach(callback: (uri: URI, diagnostics: vscode.Diagnostic[], collection: DiagnosticCollection) => any, thisArg?: any): void {
 		this._checkDisposed();
-		for (let key in this._data) {
+		this._data.forEach((value, key) => {
 			let uri = URI.parse(key);
 			callback.apply(thisArg, [uri, this.get(uri), this]);
-		}
+		});
 	}
 
 	get(uri: URI): vscode.Diagnostic[] {
 		this._checkDisposed();
-		let result = this._data[uri.toString()];
+		let result = this._data.get(uri.toString());
 		if (Array.isArray(result)) {
-			return Object.freeze(result.slice(0));
+			return <vscode.Diagnostic[]>Object.freeze(result.slice(0));
 		}
 	}
 
 	has(uri: URI): boolean {
 		this._checkDisposed();
-		return Array.isArray(this._data[uri.toString()]);
+		return Array.isArray(this._data.get(uri.toString()));
 	}
 
 	private _checkDisposed() {

src/vs/workbench/api/node/extHostDocumentSaveParticipant.ts

@@ -18,13 +18,6 @@ import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import * as vscode from 'vscode';
 
-declare class WeakMap<K, V> {
-	// delete(key: K): boolean;
-	get(key: K): V;
-	// has(key: K): boolean;
-	set(key: K, value?: V): WeakMap<K, V>;
-}
-
 export class ExtHostDocumentSaveParticipant extends ExtHostDocumentSaveParticipantShape {
 
 	private _documents: ExtHostDocuments;
@@ -168,4 +161,4 @@ export class ExtHostDocumentSaveParticipant extends ExtHostDocumentSaveParticipa
 			return TPromise.wrapError(new Error('concurrent_edits'));
 		});
 	}
-}
+}

src/vs/workbench/api/node/extHostDocuments.ts

@@ -20,16 +20,14 @@ import { asWinJsPromise } from 'vs/base/common/async';
 import { getWordAtText, ensureValidWordDefinition } from 'vs/editor/common/model/wordHelper';
 import { MainContext, MainThreadDocumentsShape, ExtHostDocumentsShape, IModelAddedData } from './extHost.protocol';
 
-const _modeId2WordDefinition: {
-	[modeId: string]: RegExp;
-} = Object.create(null);
+const _modeId2WordDefinition = new Map<string, RegExp>();
 
 function setWordDefinitionFor(modeId: string, wordDefinition: RegExp): void {
-	_modeId2WordDefinition[modeId] = wordDefinition;
+	_modeId2WordDefinition.set(modeId, wordDefinition);
 }
 
 function getWordDefinitionFor(modeId: string): RegExp {
-	return _modeId2WordDefinition[modeId];
+	return _modeId2WordDefinition.get(modeId);
 }
 
 export class ExtHostDocuments extends ExtHostDocumentsShape {
@@ -48,9 +46,9 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 	private _onDidSaveDocumentEventEmitter: Emitter<vscode.TextDocument>;
 	public onDidSaveDocument: Event<vscode.TextDocument>;
 
-	private _documentData: { [modelUri: string]: ExtHostDocumentData; };
-	private _documentLoader: { [modelUri: string]: TPromise<ExtHostDocumentData> };
-	private _documentContentProviders: { [handle: number]: vscode.TextDocumentContentProvider; };
+	private _documentData = new Map<string, ExtHostDocumentData>();
+	private _documentLoader = new Map<string, TPromise<ExtHostDocumentData>>();
+	private _documentContentProviders = new Map<number, vscode.TextDocumentContentProvider>();
 
 	private _proxy: MainThreadDocumentsShape;
 
@@ -69,17 +67,11 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 
 		this._onDidSaveDocumentEventEmitter = new Emitter<vscode.TextDocument>();
 		this.onDidSaveDocument = this._onDidSaveDocumentEventEmitter.event;
-
-		this._documentData = Object.create(null);
-		this._documentLoader = Object.create(null);
-		this._documentContentProviders = Object.create(null);
 	}
 
 	public getAllDocumentData(): ExtHostDocumentData[] {
 		const result: ExtHostDocumentData[] = [];
-		for (let key in this._documentData) {
-			result.push(this._documentData[key]);
-		}
+		this._documentData.forEach(data => result.push(data));
 		return result;
 	}
 
@@ -87,7 +79,7 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 		if (!resource) {
 			return;
 		}
-		const data = this._documentData[resource.toString()];
+		const data = this._documentData.get(resource.toString());
 		if (data) {
 			return data;
 		}
@@ -95,21 +87,21 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 
 	public ensureDocumentData(uri: URI): TPromise<ExtHostDocumentData> {
 
-		let cached = this._documentData[uri.toString()];
+		let cached = this._documentData.get(uri.toString());
 		if (cached) {
 			return TPromise.as(cached);
 		}
 
-		let promise = this._documentLoader[uri.toString()];
+		let promise = this._documentLoader.get(uri.toString());
 		if (!promise) {
 			promise = this._proxy.$tryOpenDocument(uri).then(() => {
-				delete this._documentLoader[uri.toString()];
-				return this._documentData[uri.toString()];
+				this._documentLoader.delete(uri.toString());
+				return this._documentData.get(uri.toString());
 			}, err => {
-				delete this._documentLoader[uri.toString()];
+				this._documentLoader.delete(uri.toString());
 				return TPromise.wrapError(err);
 			});
-			this._documentLoader[uri.toString()] = promise;
+			this._documentLoader.set(uri.toString(), promise);
 		}
 
 		return promise;
@@ -122,13 +114,13 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 
 		const handle = ExtHostDocuments._handlePool++;
 
-		this._documentContentProviders[handle] = provider;
+		this._documentContentProviders.set(handle, provider);
 		this._proxy.$registerTextContentProvider(handle, scheme);
 
 		let subscription: IDisposable;
 		if (typeof provider.onDidChange === 'function') {
 			subscription = provider.onDidChange(uri => {
-				if (this._documentData[uri.toString()]) {
+				if (this._documentData.has(uri.toString())) {
 					this.$provideTextDocumentContent(handle, <URI>uri).then(value => {
 						return this._proxy.$onVirtualDocumentChange(<URI>uri, value);
 					}, onUnexpectedError);
@@ -136,7 +128,7 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 			});
 		}
 		return new Disposable(() => {
-			if (delete this._documentContentProviders[handle]) {
+			if (this._documentContentProviders.delete(handle)) {
 				this._proxy.$unregisterTextContentProvider(handle);
 			}
 			if (subscription) {
@@ -147,7 +139,7 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 	}
 
 	$provideTextDocumentContent(handle: number, uri: URI): TPromise<string> {
-		const provider = this._documentContentProviders[handle];
+		const provider = this._documentContentProviders.get(handle);
 		if (!provider) {
 			return TPromise.wrapError<string>(`unsupported uri-scheme: ${uri.scheme}`);
 		}
@@ -157,15 +149,15 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 	public $acceptModelAdd(initData: IModelAddedData): void {
 		let data = new ExtHostDocumentData(this._proxy, initData.url, initData.value.lines, initData.value.EOL, initData.modeId, initData.versionId, initData.isDirty);
 		let key = data.document.uri.toString();
-		if (this._documentData[key]) {
+		if (this._documentData.has(key)) {
 			throw new Error('Document `' + key + '` already exists.');
 		}
-		this._documentData[key] = data;
+		this._documentData.set(key, data);
 		this._onDidAddDocumentEventEmitter.fire(data.document);
 	}
 
 	public $acceptModelModeChanged(strURL: string, oldModeId: string, newModeId: string): void {
-		let data = this._documentData[strURL];
+		let data = this._documentData.get(strURL);
 
 		// Treat a mode change as a remove + add
 
@@ -175,33 +167,33 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 	}
 
 	public $acceptModelSaved(strURL: string): void {
-		let data = this._documentData[strURL];
+		let data = this._documentData.get(strURL);
 		data._acceptIsDirty(false);
 		this._onDidSaveDocumentEventEmitter.fire(data.document);
 	}
 
 	public $acceptModelDirty(strURL: string): void {
-		let document = this._documentData[strURL];
+		let document = this._documentData.get(strURL);
 		document._acceptIsDirty(true);
 	}
 
 	public $acceptModelReverted(strURL: string): void {
-		let document = this._documentData[strURL];
+		let document = this._documentData.get(strURL);
 		document._acceptIsDirty(false);
 	}
 
 	public $acceptModelRemoved(strURL: string): void {
-		if (!this._documentData[strURL]) {
+		if (!this._documentData.has(strURL)) {
 			throw new Error('Document `' + strURL + '` does not exist.');
 		}
-		let data = this._documentData[strURL];
-		delete this._documentData[strURL];
+		let data = this._documentData.get(strURL);
+		this._documentData.delete(strURL);
 		this._onDidRemoveDocumentEventEmitter.fire(data.document);
 		data.dispose();
 	}
 
 	public $acceptModelChanged(strURL: string, events: editorCommon.IModelContentChangedEvent2[], isDirty: boolean): void {
-		let data = this._documentData[strURL];
+		let data = this._documentData.get(strURL);
 		data._acceptIsDirty(isDirty);
 		data.onEvents(events);
 		this._onDidChangeDocumentEventEmitter.fire({

src/vs/workbench/api/node/extHostEditors.ts

@@ -12,9 +12,9 @@ import Event, { Emitter } from 'vs/base/common/event';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { ExtHostDocuments, ExtHostDocumentData } from 'vs/workbench/api/node/extHostDocuments';
-import { Selection, Range, Position, EditorOptions, EndOfLine, TextEditorRevealType, TextEditorSelectionChangeKind } from './extHostTypes';
-import { ISingleEditOperation } from 'vs/editor/common/editorCommon';
-import { IResolvedTextEditorConfiguration, ISelectionChangeEvent } from 'vs/workbench/api/node/mainThreadEditorsTracker';
+import { Selection, Range, Position, EndOfLine, TextEditorRevealType, TextEditorSelectionChangeKind, TextEditorLineNumbersStyle } from './extHostTypes';
+import { ISingleEditOperation, TextEditorCursorStyle } from 'vs/editor/common/editorCommon';
+import { IResolvedTextEditorConfiguration, ISelectionChangeEvent, ITextEditorConfigurationUpdate } from 'vs/workbench/api/node/mainThreadEditorsTracker';
 import * as TypeConverters from './extHostTypeConverters';
 import { MainContext, MainThreadEditorsShape, ExtHostEditorsShape, ITextEditorAddData, ITextEditorPositionData } from './extHost.protocol';
 import * as vscode from 'vscode';
@@ -30,7 +30,7 @@ export class ExtHostEditors extends ExtHostEditorsShape {
 	public onDidChangeTextEditorViewColumn: Event<vscode.TextEditorViewColumnChangeEvent>;
 	private _onDidChangeTextEditorViewColumn: Emitter<vscode.TextEditorViewColumnChangeEvent>;
 
-	private _editors: { [id: string]: ExtHostTextEditor };
+	private _editors: Map<string, ExtHostTextEditor>;
 	private _proxy: MainThreadEditorsShape;
 	private _onDidChangeActiveTextEditor: Emitter<vscode.TextEditor>;
 	private _onDidChangeVisibleTextEditors: Emitter<vscode.TextEditor[]>;
@@ -56,17 +56,17 @@ export class ExtHostEditors extends ExtHostEditorsShape {
 		this._proxy = threadService.get(MainContext.MainThreadEditors);
 		this._onDidChangeActiveTextEditor = new Emitter<vscode.TextEditor>();
 		this._onDidChangeVisibleTextEditors = new Emitter<vscode.TextEditor[]>();
-		this._editors = Object.create(null);
+		this._editors = new Map<string, ExtHostTextEditor>();
 
 		this._visibleEditorIds = [];
 	}
 
 	getActiveTextEditor(): vscode.TextEditor {
-		return this._editors[this._activeEditorId];
+		return this._editors.get(this._activeEditorId);
 	}
 
 	getVisibleTextEditors(): vscode.TextEditor[] {
-		return this._visibleEditorIds.map(id => this._editors[id]);
+		return this._visibleEditorIds.map(id => this._editors.get(id));
 	}
 
 	get onDidChangeActiveTextEditor(): Event<vscode.TextEditor> {
@@ -79,7 +79,7 @@ export class ExtHostEditors extends ExtHostEditorsShape {
 
 	showTextDocument(document: vscode.TextDocument, column: vscode.ViewColumn, preserveFocus: boolean): TPromise<vscode.TextEditor> {
 		return this._proxy.$tryShowTextDocument(<URI>document.uri, TypeConverters.fromViewColumn(column), preserveFocus).then(id => {
-			let editor = this._editors[id];
+			let editor = this._editors.get(id);
 			if (editor) {
 				return editor;
 			} else {
@@ -97,11 +97,11 @@ export class ExtHostEditors extends ExtHostEditorsShape {
 	$acceptTextEditorAdd(data: ITextEditorAddData): void {
 		let document = this._extHostDocuments.getDocumentData(data.document);
 		let newEditor = new ExtHostTextEditor(this._proxy, data.id, document, data.selections.map(TypeConverters.toSelection), data.options, TypeConverters.toViewColumn(data.editorPosition));
-		this._editors[data.id] = newEditor;
+		this._editors.set(data.id, newEditor);
 	}
 
 	$acceptOptionsChanged(id: string, opts: IResolvedTextEditorConfiguration): void {
-		let editor = this._editors[id];
+		let editor = this._editors.get(id);
 		editor._acceptOptions(opts);
 		this._onDidChangeTextEditorOptions.fire({
 			textEditor: editor,
@@ -112,7 +112,7 @@ export class ExtHostEditors extends ExtHostEditorsShape {
 	$acceptSelectionsChanged(id: string, event: ISelectionChangeEvent): void {
 		const kind = TextEditorSelectionChangeKind.fromValue(event.source);
 		const selections = event.selections.map(TypeConverters.toSelection);
-		const textEditor = this._editors[id];
+		const textEditor = this._editors.get(id);
 		textEditor._acceptSelections(selections);
 		this._onDidChangeTextEditorSelection.fire({
 			textEditor,
@@ -145,7 +145,7 @@ export class ExtHostEditors extends ExtHostEditorsShape {
 
 	$acceptEditorPositionData(data: ITextEditorPositionData): void {
 		for (let id in data) {
-			let textEditor = this._editors[id];
+			let textEditor = this._editors.get(id);
 			let viewColumn = TypeConverters.toViewColumn(data[id]);
 			if (textEditor.viewColumn !== viewColumn) {
 				textEditor._acceptViewColumn(viewColumn);
@@ -165,9 +165,9 @@ export class ExtHostEditors extends ExtHostEditorsShape {
 			this.$acceptActiveEditorAndVisibleEditors(this._activeEditorId, newVisibleEditors);
 		}
 
-		let editor = this._editors[id];
+		let editor = this._editors.get(id);
 		editor.dispose();
-		delete this._editors[id];
+		this._editors.delete(id);
 	}
 }
 
@@ -293,6 +293,180 @@ function deprecated(name: string, message: string = 'Refer to the documentation
 	};
 }
 
+export class ExtHostTextEditorOptions implements vscode.TextEditorOptions {
+
+	private _proxy: MainThreadEditorsShape;
+	private _id: string;
+
+	private _tabSize: number;
+	private _insertSpaces: boolean;
+	private _cursorStyle: TextEditorCursorStyle;
+	private _lineNumbers: TextEditorLineNumbersStyle;
+
+	constructor(proxy: MainThreadEditorsShape, id: string, source: IResolvedTextEditorConfiguration) {
+		this._proxy = proxy;
+		this._id = id;
+		this._accept(source);
+	}
+
+	public _accept(source: IResolvedTextEditorConfiguration): void {
+		this._tabSize = source.tabSize;
+		this._insertSpaces = source.insertSpaces;
+		this._cursorStyle = source.cursorStyle;
+		this._lineNumbers = source.lineNumbers;
+	}
+
+	public get tabSize(): number | string {
+		return this._tabSize;
+	}
+
+	private _validateTabSize(value: number | string): number | 'auto' | null {
+		if (value === 'auto') {
+			return 'auto';
+		}
+		if (typeof value === 'number') {
+			let r = Math.floor(value);
+			return (r > 0 ? r : null);
+		}
+		if (typeof value === 'string') {
+			let r = parseInt(value, 10);
+			if (isNaN(r)) {
+				return null;
+			}
+			return (r > 0 ? r : null);
+		}
+		return null;
+	}
+
+	public set tabSize(value: number | string) {
+		let tabSize = this._validateTabSize(value);
+		if (tabSize === null) {
+			// ignore invalid call
+			return;
+		}
+		if (typeof tabSize === 'number') {
+			if (this._tabSize === tabSize) {
+				// nothing to do
+				return;
+			}
+			// reflect the new tabSize value immediately
+			this._tabSize = tabSize;
+		}
+		warnOnError(this._proxy.$trySetOptions(this._id, {
+			tabSize: tabSize
+		}));
+	}
+
+	public get insertSpaces(): boolean | string {
+		return this._insertSpaces;
+	}
+
+	private _validateInsertSpaces(value: boolean | string): boolean | 'auto' {
+		if (value === 'auto') {
+			return 'auto';
+		}
+		return (value === 'false' ? false : Boolean(value));
+	}
+
+	public set insertSpaces(value: boolean | string) {
+		let insertSpaces = this._validateInsertSpaces(value);
+		if (typeof insertSpaces === 'boolean') {
+			if (this._insertSpaces === insertSpaces) {
+				// nothing to do
+				return;
+			}
+			// reflect the new insertSpaces value immediately
+			this._insertSpaces = insertSpaces;
+		}
+		warnOnError(this._proxy.$trySetOptions(this._id, {
+			insertSpaces: insertSpaces
+		}));
+	}
+
+	public get cursorStyle(): TextEditorCursorStyle {
+		return this._cursorStyle;
+	}
+
+	public set cursorStyle(value: TextEditorCursorStyle) {
+		if (this._cursorStyle === value) {
+			// nothing to do
+			return;
+		}
+		this._cursorStyle = value;
+		warnOnError(this._proxy.$trySetOptions(this._id, {
+			cursorStyle: value
+		}));
+	}
+
+	public get lineNumbers(): TextEditorLineNumbersStyle {
+		return this._lineNumbers;
+	}
+
+	public set lineNumbers(value: TextEditorLineNumbersStyle) {
+		if (this._lineNumbers === value) {
+			// nothing to do
+			return;
+		}
+		this._lineNumbers = value;
+		warnOnError(this._proxy.$trySetOptions(this._id, {
+			lineNumbers: value
+		}));
+	}
+
+	public assign(newOptions: vscode.TextEditorOptions) {
+		let bulkConfigurationUpdate: ITextEditorConfigurationUpdate = {};
+		let hasUpdate = false;
+
+		if (typeof newOptions.tabSize !== 'undefined') {
+			let tabSize = this._validateTabSize(newOptions.tabSize);
+			if (tabSize === 'auto') {
+				hasUpdate = true;
+				bulkConfigurationUpdate.tabSize = tabSize;
+			} else if (typeof tabSize === 'number' && this._tabSize !== tabSize) {
+				// reflect the new tabSize value immediately
+				this._tabSize = tabSize;
+				hasUpdate = true;
+				bulkConfigurationUpdate.tabSize = tabSize;
+			}
+		}
+
+		if (typeof newOptions.insertSpaces !== 'undefined') {
+			let insertSpaces = this._validateInsertSpaces(newOptions.insertSpaces);
+			if (insertSpaces === 'auto') {
+				hasUpdate = true;
+				bulkConfigurationUpdate.insertSpaces = insertSpaces;
+			} else if (this._insertSpaces !== insertSpaces) {
+				// reflect the new insertSpaces value immediately
+				this._insertSpaces = insertSpaces;
+				hasUpdate = true;
+				bulkConfigurationUpdate.insertSpaces = insertSpaces;
+			}
+		}
+
+		if (typeof newOptions.cursorStyle !== 'undefined') {
+			if (this._cursorStyle !== newOptions.cursorStyle) {
+				this._cursorStyle = newOptions.cursorStyle;
+				hasUpdate = true;
+				bulkConfigurationUpdate.cursorStyle = newOptions.cursorStyle;
+			}
+		}
+
+		if (typeof newOptions.lineNumbers !== 'undefined') {
+			if (this._lineNumbers !== newOptions.lineNumbers) {
+				this._lineNumbers = newOptions.lineNumbers;
+				hasUpdate = true;
+				bulkConfigurationUpdate.lineNumbers = newOptions.lineNumbers;
+			}
+		}
+
+		if (hasUpdate) {
+			warnOnError(this._proxy.$trySetOptions(this._id, bulkConfigurationUpdate));
+		}
+	}
+
+
+}
+
 class ExtHostTextEditor implements vscode.TextEditor {
 
 	private _proxy: MainThreadEditorsShape;
@@ -300,15 +474,15 @@ class ExtHostTextEditor implements vscode.TextEditor {
 
 	private _documentData: ExtHostDocumentData;
 	private _selections: Selection[];
-	private _options: vscode.TextEditorOptions;
+	private _options: ExtHostTextEditorOptions;
 	private _viewColumn: vscode.ViewColumn;
 
-	constructor(proxy: MainThreadEditorsShape, id: string, document: ExtHostDocumentData, selections: Selection[], options: EditorOptions, viewColumn: vscode.ViewColumn) {
+	constructor(proxy: MainThreadEditorsShape, id: string, document: ExtHostDocumentData, selections: Selection[], options: IResolvedTextEditorConfiguration, viewColumn: vscode.ViewColumn) {
 		this._proxy = proxy;
 		this._id = id;
 		this._documentData = document;
 		this._selections = selections;
-		this._options = options;
+		this._options = new ExtHostTextEditorOptions(this._proxy, this._id, options);
 		this._viewColumn = viewColumn;
 	}
 
@@ -341,14 +515,11 @@ class ExtHostTextEditor implements vscode.TextEditor {
 	}
 
 	set options(value: vscode.TextEditorOptions) {
-		this._options = value;
-		this._runOnProxy(() => {
-			return this._proxy.$trySetOptions(this._id, this._options);
-		}, true);
+		this._options.assign(value);
 	}
 
-	_acceptOptions(options: EditorOptions): void {
-		this._options = options;
+	_acceptOptions(options: IResolvedTextEditorConfiguration): void {
+		this._options._accept(options);
 	}
 
 	// ---- view column
@@ -460,3 +631,9 @@ class ExtHostTextEditor implements vscode.TextEditor {
 		});
 	}
 }
+
+function warnOnError(promise: TPromise<any>): void {
+	promise.then(null, (err) => {
+		console.warn(err);
+	});
+}

src/vs/workbench/api/node/extHostExtensionService.ts

@@ -119,8 +119,10 @@ class ExtensionStoragePath {
 		return this._ready;
 	}
 
-	get value(): string {
-		return this._value;
+	value(extension: IExtensionDescription): string {
+		if (this._value) {
+			return paths.join(this._value, extension.id);
+		}
 	}
 
 	private _getOrCreateWorkspaceStoragePath(): TPromise<string> {
@@ -272,7 +274,7 @@ export class ExtHostExtensionService extends AbstractExtensionService<ExtHostExt
 				workspaceState,
 				subscriptions: [],
 				get extensionPath() { return extensionDescription.extensionFolderPath; },
-				storagePath: paths.join(this._storagePath.value, extensionDescription.id),
+				storagePath: this._storagePath.value(extensionDescription),
 				asAbsolutePath: (relativePath: string) => { return paths.normalize(paths.join(extensionDescription.extensionFolderPath, relativePath), true); }
 			});
 		});

src/vs/workbench/api/node/extHostHeapService.ts

@@ -10,20 +10,20 @@ export class ExtHostHeapService extends ExtHostHeapServiceShape {
 
 	private static _idPool = 0;
 
-	private _data: { [n: number]: any } = Object.create(null);
+	private _data = new Map<number, any>();
 
 	keep(obj: any): number {
 		const id = ExtHostHeapService._idPool++;
-		this._data[id] = obj;
+		this._data.set(id, obj);
 		return id;
 	}
 
 	delete(id: number): boolean {
-		return this._data[id];
+		return this._data.delete(id);
 	}
 
 	get<T>(id: number): T {
-		return this._data[id];
+		return this._data.get(id);
 	}
 
 	$onGarbageCollection(ids: number[]): void {
@@ -31,4 +31,4 @@ export class ExtHostHeapService extends ExtHostHeapServiceShape {
 			this.delete(id);
 		}
 	}
-}
+}

src/vs/workbench/api/node/extHostLanguageFeatures.ts

@@ -624,7 +624,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 	private _commands: ExtHostCommands;
 	private _heapService: ExtHostHeapService;
 	private _diagnostics: ExtHostDiagnostics;
-	private _adapter: { [handle: number]: Adapter } = Object.create(null);
+	private _adapter = new Map<number, Adapter>();
 
 	constructor(
 		threadService: IThreadService,
@@ -643,7 +643,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	private _createDisposable(handle: number): Disposable {
 		return new Disposable(() => {
-			delete this._adapter[handle];
+			this._adapter.delete(handle);
 			this._proxy.$unregister(handle);
 		});
 	}
@@ -653,7 +653,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 	}
 
 	private _withAdapter<A, R>(handle: number, ctor: { new (...args: any[]): A }, callback: (adapter: A) => TPromise<R>): TPromise<R> {
-		let adapter = this._adapter[handle];
+		let adapter = this._adapter.get(handle);
 		if (!(adapter instanceof ctor)) {
 			return TPromise.wrapError(new Error('no adapter found'));
 		}
@@ -664,7 +664,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerDocumentSymbolProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentSymbolProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new OutlineAdapter(this._documents, provider);
+		this._adapter.set(handle, new OutlineAdapter(this._documents, provider));
 		this._proxy.$registerOutlineSupport(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -677,9 +677,18 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerCodeLensProvider(selector: vscode.DocumentSelector, provider: vscode.CodeLensProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new CodeLensAdapter(this._documents, this._commands.converter, this._heapService, provider);
-		this._proxy.$registerCodeLensSupport(handle, selector);
-		return this._createDisposable(handle);
+		const eventHandle = typeof provider.onDidChangeCodeLenses === 'function' ? this._nextHandle() : undefined;
+
+		this._adapter.set(handle, new CodeLensAdapter(this._documents, this._commands.converter, this._heapService, provider));
+		this._proxy.$registerCodeLensSupport(handle, selector, eventHandle);
+		let result = this._createDisposable(handle);
+
+		if (eventHandle !== undefined) {
+			const subscription = provider.onDidChangeCodeLenses(_ => this._proxy.$emitCodeLensEvent(eventHandle));
+			result = Disposable.from(result, subscription);
+		}
+
+		return result;
 	}
 
 	$provideCodeLenses(handle: number, resource: URI): TPromise<modes.ICodeLensSymbol[]> {
@@ -694,7 +703,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerDefinitionProvider(selector: vscode.DocumentSelector, provider: vscode.DefinitionProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new DefinitionAdapter(this._documents, provider);
+		this._adapter.set(handle, new DefinitionAdapter(this._documents, provider));
 		this._proxy.$registerDeclaractionSupport(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -707,7 +716,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerHoverProvider(selector: vscode.DocumentSelector, provider: vscode.HoverProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new HoverAdapter(this._documents, provider);
+		this._adapter.set(handle, new HoverAdapter(this._documents, provider));
 		this._proxy.$registerHoverProvider(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -720,7 +729,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerDocumentHighlightProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentHighlightProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new DocumentHighlightAdapter(this._documents, provider);
+		this._adapter.set(handle, new DocumentHighlightAdapter(this._documents, provider));
 		this._proxy.$registerDocumentHighlightProvider(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -733,7 +742,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerReferenceProvider(selector: vscode.DocumentSelector, provider: vscode.ReferenceProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new ReferenceAdapter(this._documents, provider);
+		this._adapter.set(handle, new ReferenceAdapter(this._documents, provider));
 		this._proxy.$registerReferenceSupport(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -746,7 +755,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerCodeActionProvider(selector: vscode.DocumentSelector, provider: vscode.CodeActionProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new QuickFixAdapter(this._documents, this._commands.converter, this._diagnostics, this._heapService, provider);
+		this._adapter.set(handle, new QuickFixAdapter(this._documents, this._commands.converter, this._diagnostics, this._heapService, provider));
 		this._proxy.$registerQuickFixSupport(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -759,7 +768,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerDocumentFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentFormattingEditProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new DocumentFormattingAdapter(this._documents, provider);
+		this._adapter.set(handle, new DocumentFormattingAdapter(this._documents, provider));
 		this._proxy.$registerDocumentFormattingSupport(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -770,7 +779,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerDocumentRangeFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentRangeFormattingEditProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new RangeFormattingAdapter(this._documents, provider);
+		this._adapter.set(handle, new RangeFormattingAdapter(this._documents, provider));
 		this._proxy.$registerRangeFormattingSupport(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -781,7 +790,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerOnTypeFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.OnTypeFormattingEditProvider, triggerCharacters: string[]): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new OnTypeFormattingAdapter(this._documents, provider);
+		this._adapter.set(handle, new OnTypeFormattingAdapter(this._documents, provider));
 		this._proxy.$registerOnTypeFormattingSupport(handle, selector, triggerCharacters);
 		return this._createDisposable(handle);
 	}
@@ -794,7 +803,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerWorkspaceSymbolProvider(provider: vscode.WorkspaceSymbolProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new NavigateTypeAdapter(provider, this._heapService);
+		this._adapter.set(handle, new NavigateTypeAdapter(provider, this._heapService));
 		this._proxy.$registerNavigateTypeSupport(handle);
 		return this._createDisposable(handle);
 	}
@@ -811,7 +820,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerRenameProvider(selector: vscode.DocumentSelector, provider: vscode.RenameProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new RenameAdapter(this._documents, provider);
+		this._adapter.set(handle, new RenameAdapter(this._documents, provider));
 		this._proxy.$registerRenameSupport(handle, selector);
 		return this._createDisposable(handle);
 	}
@@ -824,7 +833,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerCompletionItemProvider(selector: vscode.DocumentSelector, provider: vscode.CompletionItemProvider, triggerCharacters: string[]): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new SuggestAdapter(this._documents, this._commands.converter, this._heapService, provider);
+		this._adapter.set(handle, new SuggestAdapter(this._documents, this._commands.converter, this._heapService, provider));
 		this._proxy.$registerSuggestSupport(handle, selector, triggerCharacters);
 		return this._createDisposable(handle);
 	}
@@ -841,7 +850,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerSignatureHelpProvider(selector: vscode.DocumentSelector, provider: vscode.SignatureHelpProvider, triggerCharacters: string[]): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new SignatureHelpAdapter(this._documents, provider);
+		this._adapter.set(handle, new SignatureHelpAdapter(this._documents, provider));
 		this._proxy.$registerSignatureHelpProvider(handle, selector, triggerCharacters);
 		return this._createDisposable(handle);
 	}
@@ -854,7 +863,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 
 	registerDocumentLinkProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentLinkProvider): vscode.Disposable {
 		const handle = this._nextHandle();
-		this._adapter[handle] = new LinkProviderAdapter(this._documents, provider);
+		this._adapter.set(handle, new LinkProviderAdapter(this._documents, provider));
 		this._proxy.$registerDocumentLinkProvider(handle, selector);
 		return this._createDisposable(handle);
 	}

src/vs/workbench/api/node/extHostTypeConverters.ts

@@ -257,6 +257,7 @@ export const CompletionItemKind = {
 			case types.CompletionItemKind.Color: return 'color';
 			case types.CompletionItemKind.File: return 'file';
 			case types.CompletionItemKind.Reference: return 'reference';
+			case types.CompletionItemKind.Folder: return 'folder';
 		}
 		return 'property';
 	},

src/vs/workbench/api/node/extHostTypes.ts

@@ -37,11 +37,6 @@ export class Disposable {
 	}
 }
 
-export interface EditorOptions {
-	tabSize: number | string;
-	insertSpaces: boolean | string;
-}
-
 export class Position {
 
 	static Min(...positions: Position[]): Position {
@@ -470,7 +465,7 @@ export class Uri extends URI { }
 export class WorkspaceEdit {
 
 	private _values: [Uri, TextEdit[]][] = [];
-	private _index: { [uri: string]: number } = Object.create(null);
+	private _index = new Map<string, number>();
 
 	replace(uri: Uri, range: Range, newText: string): void {
 		let edit = new TextEdit(range, newText);
@@ -491,21 +486,21 @@ export class WorkspaceEdit {
 	}
 
 	has(uri: Uri): boolean {
-		return typeof this._index[uri.toString()] !== 'undefined';
+		return this._index.has(uri.toString());
 	}
 
 	set(uri: Uri, edits: TextEdit[]): void {
-		let idx = this._index[uri.toString()];
+		const idx = this._index.get(uri.toString());
 		if (typeof idx === 'undefined') {
 			let newLen = this._values.push([uri, edits]);
-			this._index[uri.toString()] = newLen - 1;
+			this._index.set(uri.toString(), newLen - 1);
 		} else {
 			this._values[idx][1] = edits;
 		}
 	}
 
 	get(uri: Uri): TextEdit[] {
-		let idx = this._index[uri.toString()];
+		let idx = this._index.get(uri.toString());
 		return typeof idx !== 'undefined' && this._values[idx][1];
 	}
 
@@ -835,7 +830,8 @@ export enum CompletionItemKind {
 	Snippet = 14,
 	Color = 15,
 	File = 16,
-	Reference = 17
+	Reference = 17,
+	Folder = 18
 }
 
 export class CompletionItem {

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

@@ -11,9 +11,6 @@ import * as editorCommon from 'vs/editor/common/editorCommon';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import URI from 'vs/base/common/uri';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
-import { IEventService } from 'vs/platform/event/common/event';
-import { getResource } from 'vs/workbench/common/editor';
-import { IWorkbenchEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { TextFileModelChangeEvent, ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IFileService } from 'vs/platform/files/common/files';
@@ -29,7 +26,6 @@ export class MainThreadDocuments extends MainThreadDocumentsShape {
 	private _textModelResolverService: ITextModelResolverService;
 	private _textFileService: ITextFileService;
 	private _codeEditorService: ICodeEditorService;
-	private _editorService: IWorkbenchEditorService;
 	private _fileService: IFileService;
 	private _untitledEditorService: IUntitledEditorService;
 	private _toDispose: IDisposable[];
@@ -37,16 +33,13 @@ export class MainThreadDocuments extends MainThreadDocumentsShape {
 	private _proxy: ExtHostDocumentsShape;
 	private _modelIsSynced: { [modelId: string]: boolean; };
 	private _resourceContentProvider: { [handle: number]: IDisposable };
-	private _virtualDocumentSet: { [resource: string]: boolean };
 
 	constructor(
 		@IThreadService threadService: IThreadService,
 		@IModelService modelService: IModelService,
 		@IModeService modeService: IModeService,
-		@IEventService eventService: IEventService,
 		@ITextFileService textFileService: ITextFileService,
 		@ICodeEditorService codeEditorService: ICodeEditorService,
-		@IWorkbenchEditorService editorService: IWorkbenchEditorService,
 		@IFileService fileService: IFileService,
 		@ITextModelResolverService textModelResolverService: ITextModelResolverService,
 		@IUntitledEditorService untitledEditorService: IUntitledEditorService
@@ -57,7 +50,6 @@ export class MainThreadDocuments extends MainThreadDocumentsShape {
 		this._textModelResolverService = textModelResolverService;
 		this._textFileService = textFileService;
 		this._codeEditorService = codeEditorService;
-		this._editorService = editorService;
 		this._fileService = fileService;
 		this._untitledEditorService = untitledEditorService;
 		this._proxy = threadService.get(ExtHostContext.ExtHostDocuments);
@@ -84,12 +76,8 @@ export class MainThreadDocuments extends MainThreadDocumentsShape {
 			}
 		}));
 
-		const handle = setInterval(() => this._runDocumentCleanup(), 1000 * 60 * 3);
-		this._toDispose.push({ dispose() { clearInterval(handle); } });
-
 		this._modelToDisposeMap = Object.create(null);
 		this._resourceContentProvider = Object.create(null);
-		this._virtualDocumentSet = Object.create(null);
 	}
 
 	public dispose(): void {
@@ -229,7 +217,6 @@ export class MainThreadDocuments extends MainThreadDocumentsShape {
 			provideTextContent: (uri: URI): TPromise<editorCommon.IModel> => {
 				return this._proxy.$provideTextDocumentContent(handle, uri).then(value => {
 					if (typeof value === 'string') {
-						this._virtualDocumentSet[uri.toString()] = true;
 						const firstLineText = value.substr(0, 1 + value.search(/\r?\n/));
 						const mode = this._modeService.getOrCreateModeByFilenameOrFirstLine(uri.fsPath, firstLineText);
 						return this._modelService.createModel(value, mode, uri);
@@ -253,37 +240,4 @@ export class MainThreadDocuments extends MainThreadDocumentsShape {
 			model.setValue(value);
 		}
 	}
-
-	private _runDocumentCleanup(): void {
-
-		const toBeDisposed: URI[] = [];
-
-		// list of uris used in editors
-		const activeResources: { [uri: string]: boolean } = Object.create(null);
-		for (const editor of this._codeEditorService.listCodeEditors()) {
-			if (editor.getModel()) {
-				activeResources[editor.getModel().uri.toString()] = true;
-			}
-		}
-
-		for (const workbenchEditor of this._editorService.getVisibleEditors()) {
-			const uri = getResource(workbenchEditor.input);
-			if (uri) {
-				activeResources[uri.toString()] = true;
-			}
-		}
-
-		// intersect with virtual documents
-		for (let uri in this._virtualDocumentSet) {
-			if (!activeResources[uri]) {
-				toBeDisposed.push(URI.parse(uri));
-			}
-		}
-
-		// dispose unused virtual documents
-		for (let resource of toBeDisposed) {
-			this._modelService.destroyModel(resource);
-			delete this._virtualDocumentSet[resource.toString()];
-		}
-	}
 }

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

@@ -16,7 +16,6 @@ import { Position as EditorPosition } from 'vs/platform/editor/common/editor';
 import { IModelService } from 'vs/editor/common/services/modelService';
 import { MainThreadEditorsTracker, TextEditorRevealType, MainThreadTextEditor, IApplyEditsOptions, ITextEditorConfigurationUpdate } from 'vs/workbench/api/node/mainThreadEditorsTracker';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { IEventService } from 'vs/platform/event/common/event';
 import { equals as arrayEquals } from 'vs/base/common/arrays';
 import { equals as objectEquals } from 'vs/base/common/objects';
 import { ExtHostContext, MainThreadEditorsShape, ExtHostEditorsShape, ITextEditorPositionData } from './extHost.protocol';
@@ -40,7 +39,6 @@ export class MainThreadEditors extends MainThreadEditorsShape {
 		@IEditorGroupService editorGroupService: IEditorGroupService,
 		@ITelemetryService telemetryService: ITelemetryService,
 		@ICodeEditorService editorService: ICodeEditorService,
-		@IEventService eventService: IEventService,
 		@IModelService modelService: IModelService
 	) {
 		super();

src/vs/workbench/api/node/mainThreadEditorsTracker.ts

@@ -17,8 +17,8 @@ import { Selection } from 'vs/editor/common/core/selection';
 import { EndOfLine, TextEditorLineNumbersStyle } from 'vs/workbench/api/node/extHostTypes';
 
 export interface ITextEditorConfigurationUpdate {
-	tabSize?: number | string;
-	insertSpaces?: boolean | string;
+	tabSize?: number | 'auto';
+	insertSpaces?: boolean | 'auto';
 	cursorStyle?: EditorCommon.TextEditorCursorStyle;
 	lineNumbers?: TextEditorLineNumbersStyle;
 }
@@ -209,18 +209,12 @@ export class MainThreadTextEditor {
 			let insertSpaces = creationOpts.insertSpaces;
 			let tabSize = creationOpts.tabSize;
 
-			if (newConfiguration.insertSpaces !== 'auto') {
-				if (typeof newConfiguration.insertSpaces !== 'undefined') {
-					insertSpaces = (newConfiguration.insertSpaces === 'false' ? false : Boolean(newConfiguration.insertSpaces));
-				}
+			if (newConfiguration.insertSpaces !== 'auto' && typeof newConfiguration.insertSpaces !== 'undefined') {
+				insertSpaces = newConfiguration.insertSpaces;
 			}
-			if (newConfiguration.tabSize !== 'auto') {
-				if (typeof newConfiguration.tabSize !== 'undefined') {
-					let parsedTabSize = parseInt(<string>newConfiguration.tabSize, 10);
-					if (!isNaN(parsedTabSize)) {
-						tabSize = parsedTabSize;
-					}
-				}
+
+			if (newConfiguration.tabSize !== 'auto' && typeof newConfiguration.tabSize !== 'undefined') {
+				tabSize = newConfiguration.tabSize;
 			}
 
 			this._model.detectIndentation(insertSpaces, tabSize);
@@ -229,13 +223,10 @@ export class MainThreadTextEditor {
 
 		let newOpts: EditorCommon.ITextModelUpdateOptions = {};
 		if (typeof newConfiguration.insertSpaces !== 'undefined') {
-			newOpts.insertSpaces = (newConfiguration.insertSpaces === 'false' ? false : Boolean(newConfiguration.insertSpaces));
+			newOpts.insertSpaces = newConfiguration.insertSpaces;
 		}
 		if (typeof newConfiguration.tabSize !== 'undefined') {
-			let parsedTabSize = parseInt(<string>newConfiguration.tabSize, 10);
-			if (!isNaN(parsedTabSize)) {
-				newOpts.tabSize = parsedTabSize;
-			}
+			newOpts.tabSize = newConfiguration.tabSize;
 		}
 		this._model.updateOptions(newOpts);
 	}
@@ -588,7 +579,7 @@ export class MainThreadEditorsTracker {
 	}
 
 	private _findVisibleTextEditorIds(): string[] {
-		let result = [];
+		let result: string[] = [];
 		let modelUris = Object.keys(this._model2TextEditors);
 		for (let i = 0, len = modelUris.length; i < len; i++) {
 			let editors = this._model2TextEditors[modelUris[i]];

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

@@ -6,7 +6,7 @@
 
 import Severity from 'vs/base/common/severity';
 import { TPromise } from 'vs/base/common/winjs.base';
-import pkg from 'vs/platform/package';
+import pkg from 'vs/platform/node/package';
 import { localize } from 'vs/nls';
 import * as path from 'path';
 import URI from 'vs/base/common/uri';

src/vs/workbench/api/node/mainThreadFileSystemEventService.ts

@@ -4,15 +4,17 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { FileChangesEvent, FileChangeType } from 'vs/platform/files/common/files';
+import { FileChangeType, IFileService } from 'vs/platform/files/common/files';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { IEventService } from 'vs/platform/event/common/event';
 import { RunOnceScheduler } from 'vs/base/common/async';
 import { ExtHostContext, ExtHostFileSystemEventServiceShape, FileSystemEvents } from './extHost.protocol';
 
 export class MainThreadFileSystemEventService {
 
-	constructor( @IEventService eventService: IEventService, @IThreadService threadService: IThreadService) {
+	constructor(
+		@IThreadService threadService: IThreadService,
+		@IFileService fileService: IFileService
+	) {
 
 		const proxy: ExtHostFileSystemEventServiceShape = threadService.get(ExtHostContext.ExtHostFileSystemEventService);
 		const events: FileSystemEvents = {
@@ -28,7 +30,7 @@ export class MainThreadFileSystemEventService {
 			events.deleted.length = 0;
 		}, 100);
 
-		eventService.addListener2('files:fileChanges', (event: FileChangesEvent) => {
+		fileService.onFileChanges(event => {
 			for (let change of event.changes) {
 				switch (change.type) {
 					case FileChangeType.ADDED:

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

@@ -12,17 +12,6 @@ import { consumeSignals, GCSignal } from 'gc-signals';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 
-
-declare class WeakMap<K, V> {
-	set(key: K, value?: V): WeakMap<K, V>;
-}
-
-declare class Set<E> {
-	add(e: E): this;
-	has(e: E): boolean;
-	delete(e: E): boolean;
-}
-
 export const IHeapService = createDecorator<IHeapService>('heapService');
 
 export interface IHeapService {

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

@@ -6,6 +6,7 @@
 
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IDisposable } from 'vs/base/common/lifecycle';
+import { Emitter } from 'vs/base/common/event';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import * as vscode from 'vscode';
 import { IReadOnlyModel, ISingleEditOperation } from 'vs/editor/common/editorCommon';
@@ -57,15 +58,32 @@ export class MainThreadLanguageFeatures extends MainThreadLanguageFeaturesShape
 
 	// --- code lens
 
-	$registerCodeLensSupport(handle: number, selector: vscode.DocumentSelector): TPromise<any> {
-		this._registrations[handle] = modes.CodeLensProviderRegistry.register(selector, <modes.CodeLensProvider>{
+	$registerCodeLensSupport(handle: number, selector: vscode.DocumentSelector, eventHandle: number): TPromise<any> {
+
+		const provider = <modes.CodeLensProvider>{
 			provideCodeLenses: (model: IReadOnlyModel, token: CancellationToken): modes.ICodeLensSymbol[] | Thenable<modes.ICodeLensSymbol[]> => {
 				return this._heapService.trackRecursive(wireCancellationToken(token, this._proxy.$provideCodeLenses(handle, model.uri)));
 			},
 			resolveCodeLens: (model: IReadOnlyModel, codeLens: modes.ICodeLensSymbol, token: CancellationToken): modes.ICodeLensSymbol | Thenable<modes.ICodeLensSymbol> => {
 				return this._heapService.trackRecursive(wireCancellationToken(token, this._proxy.$resolveCodeLens(handle, model.uri, codeLens)));
 			}
-		});
+		};
+
+		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);
+		return undefined;
+	}
+
+	$emitCodeLensEvent(eventHandle: number, event?: any): TPromise<any> {
+		const obj = this._registrations[eventHandle];
+		if (obj instanceof Emitter) {
+			obj.fire(event);
+		}
 		return undefined;
 	}
 

src/vs/workbench/api/node/mainThreadQuickOpen.ts

@@ -7,7 +7,7 @@
 import { TPromise } from 'vs/base/common/winjs.base';
 import { asWinJsPromise } from 'vs/base/common/async';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { IQuickOpenService, IPickOptions, IInputOptions } from 'vs/workbench/services/quickopen/common/quickOpenService';
+import { IQuickOpenService, IPickOptions, IInputOptions } from 'vs/platform/quickOpen/common/quickOpen';
 import { InputBoxOptions } from 'vscode';
 import { ExtHostContext, MainThreadQuickOpenShape, ExtHostQuickOpenShape, MyQuickPickItems } from './extHost.protocol';
 

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

@@ -13,9 +13,10 @@ import { IThreadService } from 'vs/workbench/services/thread/common/threadServic
 import { ISaveParticipant, ITextFileEditorModel, SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { IPosition, IModel, ICommonCodeEditor, ISingleEditOperation, IIdentifiedSingleEditOperation } from 'vs/editor/common/editorCommon';
+import { IModel, ICommonCodeEditor, ISingleEditOperation, IIdentifiedSingleEditOperation } from 'vs/editor/common/editorCommon';
 import { Range } from 'vs/editor/common/core/range';
 import { Selection } from 'vs/editor/common/core/selection';
+import { Position } from 'vs/editor/common/core/position';
 import { trimTrailingWhitespace } from 'vs/editor/common/commands/trimTrailingWhitespaceCommand';
 import { getDocumentFormattingEdits } from 'vs/editor/contrib/format/common/format';
 import { EditOperationsCommand } from 'vs/editor/contrib/format/common/formatCommand';
@@ -47,7 +48,7 @@ class TrimWhitespaceParticipant implements INamedSaveParticpant {
 
 	private doTrimTrailingWhitespace(model: IModel, isAutoSaved: boolean): void {
 		let prevSelection: Selection[] = [new Selection(1, 1, 1, 1)];
-		const cursors: IPosition[] = [];
+		const cursors: Position[] = [];
 
 		let editor = findEditor(model, this.codeEditorService);
 		if (editor) {
@@ -55,12 +56,7 @@ class TrimWhitespaceParticipant implements INamedSaveParticpant {
 			// Collect active cursors in `cursors` only if `isAutoSaved` to avoid having the cursors jump
 			prevSelection = editor.getSelections();
 			if (isAutoSaved) {
-				cursors.push(...prevSelection.map(s => {
-					return {
-						lineNumber: s.positionLineNumber,
-						column: s.positionColumn
-					};
-				}));
+				cursors.push(...prevSelection.map(s => new Position(s.positionLineNumber, s.positionColumn)));
 			}
 		}
 
@@ -125,7 +121,11 @@ export class FinalNewLineParticipant implements INamedSaveParticpant {
 			prevSelection = editor.getSelections();
 		}
 
-		model.pushEditOperations(prevSelection, [EditOperation.insert({ lineNumber: lineCount + 1, column: 0 }, model.getEOL())], (edits) => prevSelection);
+		model.pushEditOperations(prevSelection, [EditOperation.insert(new Position(lineCount, model.getLineMaxColumn(lineCount)), model.getEOL())], edits => prevSelection);
+
+		if (editor) {
+			editor.setSelections(prevSelection);
+		}
 	}
 }
 
@@ -251,8 +251,8 @@ export class SaveParticipant implements ISaveParticipant {
 
 		this._saveParticipants = [
 			instantiationService.createInstance(TrimWhitespaceParticipant),
-			instantiationService.createInstance(FinalNewLineParticipant),
 			instantiationService.createInstance(FormatOnSaveParticipant),
+			instantiationService.createInstance(FinalNewLineParticipant),
 			instantiationService.createInstance(ExtHostSaveParticipant)
 		];
 

src/vs/workbench/api/node/mainThreadTerminalService.ts

@@ -31,7 +31,7 @@ export class MainThreadTerminalService extends MainThreadTerminalServiceShape {
 	}
 
 	public $createTerminal(name?: string, shellPath?: string, shellArgs?: string[]): TPromise<number> {
-		return TPromise.as(this.terminalService.createInstance(name, shellPath, shellArgs).id);
+		return TPromise.as(this.terminalService.createInstance(name, shellPath, shellArgs, true).id);
 	}
 
 	public $show(terminalId: number, preserveFocus: boolean): void {

src/vs/workbench/api/node/mainThreadTreeExplorers.ts

@@ -16,7 +16,7 @@ export class MainThreadTreeExplorers extends MainThreadTreeExplorersShape {
 	private _proxy: ExtHostTreeExplorersShape;
 
 	constructor(
-		@IThreadService private threadService: IThreadService,
+		@IThreadService threadService: IThreadService,
 		@ITreeExplorerService private treeExplorerService: ITreeExplorerService,
 		@IMessageService private messageService: IMessageService,
 		@ICommandService private commandService: ICommandService

src/vs/workbench/api/node/mainThreadWorkspace.ts

@@ -6,8 +6,7 @@
 
 import { isPromiseCanceledError } from 'vs/base/common/errors';
 import { ISearchService, QueryType } from 'vs/platform/search/common/search';
-import { IWorkspaceContextService, IWorkspace } from 'vs/platform/workspace/common/workspace';
-import { IEventService } from 'vs/platform/event/common/event';
+import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
 import { IWorkbenchEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
 import { ICommonCodeEditor } from 'vs/editor/common/editorCommon';
@@ -16,43 +15,44 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { Uri } from 'vscode';
 import { MainThreadWorkspaceShape } from './extHost.protocol';
 import { ITextModelResolverService } from 'vs/editor/common/services/resolverService';
+import { IFileService } from 'vs/platform/files/common/files';
 
 export class MainThreadWorkspace extends MainThreadWorkspaceShape {
 
 	private _activeSearches: { [id: number]: TPromise<Uri[]> } = Object.create(null);
 	private _searchService: ISearchService;
-	private _workspace: IWorkspace;
+	private _contextService: IWorkspaceContextService;
 	private _textFileService: ITextFileService;
 	private _editorService: IWorkbenchEditorService;
 	private _textModelResolverService: ITextModelResolverService;
-	private _eventService: IEventService;
+	private _fileService: IFileService;
 
 	constructor(
 		@ISearchService searchService: ISearchService,
 		@IWorkspaceContextService contextService: IWorkspaceContextService,
-		@ITextFileService textFileService,
-		@IWorkbenchEditorService editorService,
-		@ITextModelResolverService textModelResolverService,
-		@IEventService eventService
+		@ITextFileService textFileService: ITextFileService,
+		@IWorkbenchEditorService editorService: IWorkbenchEditorService,
+		@ITextModelResolverService textModelResolverService: ITextModelResolverService,
+		@IFileService fileService: IFileService
 	) {
 		super();
 
 		this._searchService = searchService;
-		this._workspace = contextService.getWorkspace();
+		this._contextService = contextService;
 		this._textFileService = textFileService;
 		this._editorService = editorService;
-		this._eventService = eventService;
+		this._fileService = fileService;
 		this._textModelResolverService = textModelResolverService;
 	}
 
 	$startSearch(include: string, exclude: string, maxResults: number, requestId: number): Thenable<Uri[]> {
-
-		if (!this._workspace) {
+		const workspace = this._contextService.getWorkspace();
+		if (!workspace) {
 			return;
 		}
 
 		const search = this._searchService.search({
-			folderResources: [this._workspace.resource],
+			folderResources: [workspace.resource],
 			type: QueryType.File,
 			maxResults,
 			includePattern: { [include]: true },
@@ -99,7 +99,7 @@ export class MainThreadWorkspace extends MainThreadWorkspaceShape {
 			}
 		}
 
-		return bulkEdit(this._eventService, this._textModelResolverService, codeEditor, edits)
+		return bulkEdit(this._textModelResolverService, codeEditor, edits, this._fileService)
 			.then(() => true);
 	}
 }