Merge branch 'master' into joh/ftp

src/vs/workbench/api/electron-browser/mainThreadDebugService.ts

@@ -4,10 +4,11 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import URI from 'vs/base/common/uri';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import uri from 'vs/base/common/uri';
 import { IDebugService, IConfig, IDebugConfigurationProvider } from 'vs/workbench/parts/debug/common/debug';
 import { TPromise } from 'vs/base/common/winjs.base';
+import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
 import { ExtHostContext, ExtHostDebugServiceShape, MainThreadDebugServiceShape, DebugSessionUUID, MainContext, IExtHostContext } from '../node/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 
@@ -19,7 +20,8 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape {
 
 	constructor(
 		extHostContext: IExtHostContext,
-		@IDebugService private debugService: IDebugService
+		@IDebugService private debugService: IDebugService,
+		@IWorkspaceContextService private contextService: IWorkspaceContextService,
 	) {
 		this._proxy = extHostContext.get(ExtHostContext.ExtHostDebugService);
 		this._toDispose = [];
@@ -69,19 +71,22 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape {
 		return TPromise.as<void>(undefined);
 	}
 
-	public $startDebugging(folderUri: URI | undefined, nameOrConfiguration: string | IConfig): TPromise<boolean> {
-		return this.debugService.startDebugging(folderUri, nameOrConfiguration).then(x => {
+	public $startDebugging(folderUri: uri | undefined, nameOrConfiguration: string | IConfig): TPromise<boolean> {
+		const folder = folderUri ? this.contextService.getWorkspace().folders.filter(wf => wf.uri.toString() === folderUri.toString()).pop() : undefined;
+		return this.debugService.startDebugging(folder, nameOrConfiguration).then(x => {
 			return true;
 		}, err => {
 			return TPromise.wrapError(err && err.message ? err.message : 'cannot start debugging');
 		});
 	}
 
-	public $startDebugSession(folderUri: URI | undefined, configuration: IConfig): TPromise<DebugSessionUUID> {
+	public $startDebugSession(folderUri: uri | undefined, configuration: IConfig): TPromise<DebugSessionUUID> {
 		if (configuration.request !== 'launch' && configuration.request !== 'attach') {
 			return TPromise.wrapError(new Error(`only 'launch' or 'attach' allowed for 'request' attribute`));
 		}
-		return this.debugService.createProcess(folderUri, configuration).then(process => {
+
+		const folder = folderUri ? this.contextService.getWorkspace().folders.filter(wf => wf.uri.toString() === folderUri.toString()).pop() : undefined;
+		return this.debugService.createProcess(folder, configuration).then(process => {
 			if (process) {
 				return <DebugSessionUUID>process.getId();
 			}

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

@@ -250,7 +250,7 @@ export class MainThreadDocumentsAndEditors {
 		const mainThreadDocuments = new MainThreadDocuments(this, extHostContext, this._modelService, modeService, this._textFileService, fileService, textModelResolverService, untitledEditorService);
 		extHostContext.set(MainContext.MainThreadDocuments, mainThreadDocuments);
 
-		const mainThreadEditors = new MainThreadEditors(this, extHostContext, codeEditorService, this._workbenchEditorService, editorGroupService, telemetryService);
+		const mainThreadEditors = new MainThreadEditors(this, extHostContext, codeEditorService, this._workbenchEditorService, editorGroupService, telemetryService, textModelResolverService, fileService, this._modelService);
 		extHostContext.set(MainContext.MainThreadEditors, mainThreadEditors);
 
 		// It is expected that the ctor of the state computer calls our `_onDelta`.

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

@@ -8,7 +8,7 @@ import URI from 'vs/base/common/uri';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { disposed } from 'vs/base/common/errors';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { ISingleEditOperation, IDecorationRenderOptions, IDecorationOptions, ILineChange } from 'vs/editor/common/editorCommon';
+import { ISingleEditOperation, IDecorationRenderOptions, IDecorationOptions, ILineChange, ICommonCodeEditor, isCommonCodeEditor } from 'vs/editor/common/editorCommon';
 import { ICodeEditorService } from 'vs/editor/common/services/codeEditorService';
 import { IWorkbenchEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IEditorGroupService } from 'vs/workbench/services/group/common/groupService';
@@ -18,9 +18,13 @@ import { ITextEditorConfigurationUpdate, TextEditorRevealType, IApplyEditsOption
 import { MainThreadDocumentsAndEditors } from './mainThreadDocumentsAndEditors';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { equals as objectEquals } from 'vs/base/common/objects';
-import { ExtHostContext, MainThreadEditorsShape, ExtHostEditorsShape, ITextDocumentShowOptions, ITextEditorPositionData, IExtHostContext } from '../node/extHost.protocol';
+import { ExtHostContext, MainThreadEditorsShape, ExtHostEditorsShape, ITextDocumentShowOptions, ITextEditorPositionData, IExtHostContext, IWorkspaceResourceEdit } from '../node/extHost.protocol';
 import { IRange } from 'vs/editor/common/core/range';
 import { ISelection } from 'vs/editor/common/core/selection';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
+import { IFileService } from 'vs/platform/files/common/files';
+import { bulkEdit, IResourceEdit } from 'vs/editor/common/services/bulkEdit';
+import { IModelService } from 'vs/editor/common/services/modelService';
 
 export class MainThreadEditors implements MainThreadEditorsShape {
 
@@ -38,7 +42,10 @@ export class MainThreadEditors implements MainThreadEditorsShape {
 		@ICodeEditorService private _codeEditorService: ICodeEditorService,
 		@IWorkbenchEditorService workbenchEditorService: IWorkbenchEditorService,
 		@IEditorGroupService editorGroupService: IEditorGroupService,
-		@ITelemetryService telemetryService: ITelemetryService
+		@ITelemetryService telemetryService: ITelemetryService,
+		@ITextModelService private readonly _textModelResolverService: ITextModelService,
+		@IFileService private readonly _fileService: IFileService,
+		@IModelService private readonly _modelService: IModelService,
 	) {
 		this._proxy = extHostContext.get(ExtHostContext.ExtHostEditors);
 		this._documentsAndEditors = documentsAndEditors;
@@ -194,6 +201,52 @@ export class MainThreadEditors implements MainThreadEditorsShape {
 		return TPromise.as(this._documentsAndEditors.getEditor(id).applyEdits(modelVersionId, edits, opts));
 	}
 
+	$tryApplyWorkspaceEdit(workspaceResourceEdits: IWorkspaceResourceEdit[]): TPromise<boolean> {
+
+		// First check if loaded models were not changed in the meantime
+		for (let i = 0, len = workspaceResourceEdits.length; i < len; i++) {
+			const workspaceResourceEdit = workspaceResourceEdits[i];
+			if (workspaceResourceEdit.modelVersionId) {
+				let model = this._modelService.getModel(workspaceResourceEdit.resource);
+				if (model && model.getVersionId() !== workspaceResourceEdit.modelVersionId) {
+					// model changed in the meantime
+					return TPromise.as(false);
+				}
+			}
+		}
+
+		// Convert to shape expected by bulkEdit below
+		let resourceEdits: IResourceEdit[] = [];
+		for (let i = 0, len = workspaceResourceEdits.length; i < len; i++) {
+			const workspaceResourceEdit = workspaceResourceEdits[i];
+			const uri = workspaceResourceEdit.resource;
+			const edits = workspaceResourceEdit.edits;
+
+			for (let j = 0, lenJ = edits.length; j < lenJ; j++) {
+				const edit = edits[j];
+
+				resourceEdits.push({
+					resource: <URI>uri,
+					newText: edit.newText,
+					newEol: edit.newEol,
+					range: edit.range
+				});
+			}
+		}
+
+		let codeEditor: ICommonCodeEditor;
+		let editor = this._workbenchEditorService.getActiveEditor();
+		if (editor) {
+			let candidate = editor.getControl();
+			if (isCommonCodeEditor(candidate)) {
+				codeEditor = candidate;
+			}
+		}
+
+		return bulkEdit(this._textModelResolverService, codeEditor, resourceEdits, this._fileService)
+			.then(() => true);
+	}
+
 	$tryInsertSnippet(id: string, template: string, ranges: IRange[], opts: IUndoStopOptions): TPromise<boolean> {
 		if (!this._documentsAndEditors.getEditor(id)) {
 			return TPromise.wrapError<boolean>(disposed(`TextEditor(${id})`));

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

@@ -286,7 +286,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 	$registerDocumentColorProvider(handle: number, selector: vscode.DocumentSelector): TPromise<any> {
 		const proxy = this._proxy;
 		this._registrations[handle] = modes.ColorProviderRegistry.register(selector, <modes.DocumentColorProvider>{
-			provideColorRanges: (model, token) => {
+			provideDocumentColors: (model, token) => {
 				return wireCancellationToken(token, proxy.$provideDocumentColors(handle, model.uri))
 					.then(documentColors => {
 						return documentColors.map(documentColor => {
@@ -305,8 +305,12 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 						});
 					});
 			},
-			resolveColor: (color, format, token) => {
-				return wireCancellationToken(token, proxy.$resolveDocumentColor(handle, color, format));
+
+			provideColorPresentations: (colorInfo, token) => {
+				return wireCancellationToken(token, proxy.$provideColorPresentations(handle, {
+					color: [colorInfo.color.red, colorInfo.color.green, colorInfo.color.blue, colorInfo.color.alpha],
+					range: colorInfo.range
+				}));
 			}
 		});
 

src/vs/workbench/api/electron-browser/mainThreadTask.ts

@@ -6,6 +6,9 @@
 
 import { TPromise } from 'vs/base/common/winjs.base';
 
+import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
+
+import { ContributedTask, ExtensionTaskSourceTransfer } from 'vs/workbench/parts/tasks/common/tasks';
 import { ITaskService } from 'vs/workbench/parts/tasks/common/taskService';
 
 import { ExtHostContext, MainThreadTaskShape, ExtHostTaskShape, MainContext, IExtHostContext } from '../node/extHost.protocol';
@@ -19,7 +22,8 @@ export class MainThreadTask implements MainThreadTaskShape {
 
 	constructor(
 		extHostContext: IExtHostContext,
-		@ITaskService private _taskService: ITaskService
+		@ITaskService private _taskService: ITaskService,
+		@IWorkspaceContextService private _workspaceContextServer: IWorkspaceContextService
 	) {
 		this._proxy = extHostContext.get(ExtHostContext.ExtHostTask);
 		this._activeHandles = Object.create(null);
@@ -35,7 +39,17 @@ export class MainThreadTask implements MainThreadTaskShape {
 	public $registerTaskProvider(handle: number): TPromise<void> {
 		this._taskService.registerTaskProvider(handle, {
 			provideTasks: () => {
-				return this._proxy.$provideTasks(handle);
+				return this._proxy.$provideTasks(handle).then((value) => {
+					for (let task of value.tasks) {
+						if (ContributedTask.is(task)) {
+							let uri = (task._source as any as ExtensionTaskSourceTransfer).__workspaceFolder;
+							if (uri) {
+								(task._source as any).workspaceFolder = this._workspaceContextServer.getWorkspaceFolder(uri);
+							}
+						}
+					}
+					return value;
+				});
 			}
 		});
 		this._activeHandles[handle] = true;

src/vs/workbench/api/electron-browser/mainThreadWorkspace.ts

@@ -8,13 +8,9 @@ import { isPromiseCanceledError } from 'vs/base/common/errors';
 import URI from 'vs/base/common/uri';
 import { ISearchService, QueryType, ISearchQuery } from 'vs/platform/search/common/search';
 import { IWorkspaceContextService, WorkbenchState } 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, isCommonCodeEditor } from 'vs/editor/common/editorCommon';
-import { bulkEdit, IResourceEdit } from 'vs/editor/common/services/bulkEdit';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { MainThreadWorkspaceShape, ExtHostWorkspaceShape, ExtHostContext, MainContext, IExtHostContext } from '../node/extHost.protocol';
-import { ITextModelService } from 'vs/editor/common/services/resolverService';
 import { IFileService } from 'vs/platform/files/common/files';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
@@ -32,13 +28,11 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 		@ISearchService private readonly _searchService: ISearchService,
 		@IWorkspaceContextService private readonly _contextService: IWorkspaceContextService,
 		@ITextFileService private readonly _textFileService: ITextFileService,
-		@IWorkbenchEditorService private readonly _editorService: IWorkbenchEditorService,
-		@ITextModelService private readonly _textModelResolverService: ITextModelService,
 		@IExperimentService private _experimentService: IExperimentService,
 		@IFileService private readonly _fileService: IFileService
 	) {
 		this._proxy = extHostContext.get(ExtHostContext.ExtHostWorkspace);
-		this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this, this._toDispose);
+		this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspaceState, this, this._toDispose);
 	}
 
 	dispose(): void {
@@ -52,7 +46,7 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 
 	// --- workspace ---
 
-	private _onDidChangeWorkspace(): void {
+	private _onDidChangeWorkspaceState(): void {
 		this._proxy.$acceptWorkspaceData(this._contextService.getWorkbenchState() === WorkbenchState.EMPTY ? null : this._contextService.getWorkspace());
 	}
 
@@ -106,20 +100,5 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 			return result.results.every(each => each.success === true);
 		});
 	}
-
-	$applyWorkspaceEdit(edits: IResourceEdit[]): TPromise<boolean> {
-
-		let codeEditor: ICommonCodeEditor;
-		let editor = this._editorService.getActiveEditor();
-		if (editor) {
-			let candidate = editor.getControl();
-			if (isCommonCodeEditor(candidate)) {
-				codeEditor = candidate;
-			}
-		}
-
-		return bulkEdit(this._textModelResolverService, codeEditor, edits, this._fileService)
-			.then(() => true);
-	}
 }
 

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

@@ -86,7 +86,7 @@ export function createApiFactory(
 	const extHostDocumentsAndEditors = threadService.set(ExtHostContext.ExtHostDocumentsAndEditors, new ExtHostDocumentsAndEditors(threadService, extensionService));
 	const extHostDocuments = threadService.set(ExtHostContext.ExtHostDocuments, new ExtHostDocuments(threadService, extHostDocumentsAndEditors));
 	const extHostDocumentContentProviders = threadService.set(ExtHostContext.ExtHostDocumentContentProviders, new ExtHostDocumentContentProvider(threadService, extHostDocumentsAndEditors));
-	const extHostDocumentSaveParticipant = threadService.set(ExtHostContext.ExtHostDocumentSaveParticipant, new ExtHostDocumentSaveParticipant(extHostDocuments, threadService.get(MainContext.MainThreadWorkspace)));
+	const extHostDocumentSaveParticipant = threadService.set(ExtHostContext.ExtHostDocumentSaveParticipant, new ExtHostDocumentSaveParticipant(extHostDocuments, threadService.get(MainContext.MainThreadEditors)));
 	const extHostEditors = threadService.set(ExtHostContext.ExtHostEditors, new ExtHostEditors(threadService, extHostDocumentsAndEditors));
 	const extHostCommands = threadService.set(ExtHostContext.ExtHostCommands, new ExtHostCommands(threadService, extHostHeapService));
 	const extHostTreeViews = threadService.set(ExtHostContext.ExtHostTreeViews, new ExtHostTreeViews(threadService.get(MainContext.MainThreadTreeViews), extHostCommands));
@@ -420,7 +420,7 @@ export function createApiFactory(
 				return extHostWorkspace.saveAll(includeUntitled);
 			},
 			applyEdit(edit: vscode.WorkspaceEdit): TPromise<boolean> {
-				return extHostWorkspace.appyEdit(edit);
+				return extHostEditors.applyWorkspaceEdit(edit);
 			},
 			createFileSystemWatcher: (pattern, ignoreCreate, ignoreChange, ignoreDelete): vscode.FileSystemWatcher => {
 				return extHostFileSystemEvent.createFileSystemWatcher(pattern, ignoreCreate, ignoreChange, ignoreDelete);
@@ -554,8 +554,8 @@ export function createApiFactory(
 			CancellationTokenSource: CancellationTokenSource,
 			CodeLens: extHostTypes.CodeLens,
 			Color: extHostTypes.Color,
-			ColorFormat: extHostTypes.ColorFormat,
-			ColorRange: extHostTypes.ColorRange,
+			ColorPresentation: extHostTypes.ColorPresentation,
+			ColorInformation: extHostTypes.ColorInformation,
 			EndOfLine: extHostTypes.EndOfLine,
 			CompletionItem: extHostTypes.CompletionItem,
 			CompletionItemKind: extHostTypes.CompletionItemKind,

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

@@ -26,7 +26,6 @@ import { IProgressOptions, IProgressStep } from 'vs/platform/progress/common/pro
 
 import * as editorCommon from 'vs/editor/common/editorCommon';
 import * as modes from 'vs/editor/common/modes';
-import { IResourceEdit } from 'vs/editor/common/services/bulkEdit';
 import { ITextSource } from 'vs/editor/common/model/textSource';
 
 import { ConfigurationTarget } from 'vs/workbench/services/configuration/common/configurationEditing';
@@ -190,6 +189,16 @@ export interface ITextDocumentShowOptions {
 	selection?: IRange;
 }
 
+export interface IWorkspaceResourceEdit {
+	resource: URI;
+	modelVersionId?: number;
+	edits: {
+		range?: IRange;
+		newText: string;
+		newEol?: editorCommon.EndOfLineSequence;
+	}[];
+}
+
 export interface MainThreadEditorsShape extends IDisposable {
 	$tryShowTextDocument(resource: URI, options: ITextDocumentShowOptions): TPromise<string>;
 	$registerTextEditorDecorationType(key: string, options: editorCommon.IDecorationRenderOptions): void;
@@ -201,6 +210,7 @@ export interface MainThreadEditorsShape extends IDisposable {
 	$tryRevealRange(id: string, range: IRange, revealType: TextEditorRevealType): TPromise<any>;
 	$trySetSelections(id: string, selections: ISelection[]): TPromise<any>;
 	$tryApplyEdits(id: string, modelVersionId: number, edits: editorCommon.ISingleEditOperation[], opts: IApplyEditsOptions): TPromise<boolean>;
+	$tryApplyWorkspaceEdit(workspaceResourceEdits: IWorkspaceResourceEdit[]): TPromise<boolean>;
 	$tryInsertSnippet(id: string, template: string, selections: IRange[], opts: IUndoStopOptions): TPromise<any>;
 	$getDiffInformation(id: string): TPromise<editorCommon.ILineChange[]>;
 }
@@ -302,7 +312,6 @@ export interface MainThreadWorkspaceShape extends IDisposable {
 	$startSearch(include: string, exclude: string, maxResults: number, requestId: number): Thenable<URI[]>;
 	$cancelSearch(requestId: number): Thenable<boolean>;
 	$saveAll(includeUntitled?: boolean): Thenable<boolean>;
-	$applyWorkspaceEdit(edits: IResourceEdit[]): TPromise<boolean>;
 }
 
 export interface MainThreadFileSystemShape extends IDisposable {
@@ -377,8 +386,8 @@ export type DebugSessionUUID = string;
 export interface MainThreadDebugServiceShape extends IDisposable {
 	$registerDebugConfigurationProvider(type: string, hasProvideMethod: boolean, hasResolveMethod: boolean, handle: number): TPromise<any>;
 	$unregisterDebugConfigurationProvider(handle: number): TPromise<any>;
-	$startDebugging(folderUri: URI | undefined, nameOrConfig: string | vscode.DebugConfiguration): TPromise<boolean>;
-	$startDebugSession(folderUri: URI | undefined, config: vscode.DebugConfiguration): TPromise<DebugSessionUUID>;
+	$startDebugging(folder: URI | undefined, nameOrConfig: string | vscode.DebugConfiguration): TPromise<boolean>;
+	$startDebugSession(folder: URI | undefined, config: vscode.DebugConfiguration): TPromise<DebugSessionUUID>;
 	$customDebugAdapterRequest(id: DebugSessionUUID, command: string, args: any): TPromise<any>;
 }
 
@@ -550,7 +559,7 @@ export interface ExtHostLanguageFeaturesShape {
 	$provideDocumentLinks(handle: number, resource: URI): TPromise<modes.ILink[]>;
 	$resolveDocumentLink(handle: number, link: modes.ILink): TPromise<modes.ILink>;
 	$provideDocumentColors(handle: number, resource: URI): TPromise<IRawColorInfo[]>;
-	$resolveDocumentColor(handle: number, color: modes.IColor, colorFormat: modes.ColorFormat): TPromise<string>;
+	$provideColorPresentations(handle: number, colorInfo: IRawColorInfo): TPromise<modes.IColorPresentation[]>;
 }
 
 export interface ExtHostQuickOpenShape {

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

@@ -95,12 +95,10 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 	}
 
 	public startDebugging(folder: vscode.WorkspaceFolder | undefined, nameOrConfig: string | vscode.DebugConfiguration): TPromise<boolean> {
-
 		return this._debugServiceProxy.$startDebugging(folder ? <URI>folder.uri : undefined, nameOrConfig);
 	}
 
 	public startDebugSession(folder: vscode.WorkspaceFolder | undefined, config: vscode.DebugConfiguration): TPromise<vscode.DebugSession> {
-
 		return this._debugServiceProxy.$startDebugSession(folder ? <URI>folder.uri : undefined, config).then((id: DebugSessionUUID) => {
 			const debugSession = new ExtHostDebugSession(this._debugServiceProxy, id, config.type, config.name);
 			this._debugSessions.set(id, debugSession);

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

@@ -10,10 +10,9 @@ import URI from 'vs/base/common/uri';
 import { sequence, always } from 'vs/base/common/async';
 import { illegalState } from 'vs/base/common/errors';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { MainThreadWorkspaceShape, ExtHostDocumentSaveParticipantShape } from 'vs/workbench/api/node/extHost.protocol';
+import { ExtHostDocumentSaveParticipantShape, MainThreadEditorsShape, IWorkspaceResourceEdit } from 'vs/workbench/api/node/extHost.protocol';
 import { TextEdit } from 'vs/workbench/api/node/extHostTypes';
 import { fromRange, TextDocumentSaveReason, EndOfLine } from 'vs/workbench/api/node/extHostTypeConverters';
-import { IResourceEdit } from 'vs/editor/common/services/bulkEdit';
 import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import * as vscode from 'vscode';
@@ -21,14 +20,14 @@ import * as vscode from 'vscode';
 export class ExtHostDocumentSaveParticipant implements ExtHostDocumentSaveParticipantShape {
 
 	private _documents: ExtHostDocuments;
-	private _workspace: MainThreadWorkspaceShape;
+	private _mainThreadEditors: MainThreadEditorsShape;
 	private _callbacks = new CallbackList();
 	private _badListeners = new WeakMap<Function, number>();
 	private _thresholds: { timeout: number; errors: number; };
 
-	constructor(documents: ExtHostDocuments, workspace: MainThreadWorkspaceShape, thresholds: { timeout: number; errors: number; } = { timeout: 1500, errors: 3 }) {
+	constructor(documents: ExtHostDocuments, mainThreadEditors: MainThreadEditorsShape, thresholds: { timeout: number; errors: number; } = { timeout: 1500, errors: 3 }) {
 		this._documents = documents;
-		this._workspace = workspace;
+		this._mainThreadEditors = mainThreadEditors;
 		this._thresholds = thresholds;
 	}
 
@@ -133,13 +132,15 @@ export class ExtHostDocumentSaveParticipant implements ExtHostDocumentSavePartic
 
 		}).then(values => {
 
-			let edits: IResourceEdit[] = [];
+			let workspaceResourceEdit: IWorkspaceResourceEdit = {
+				resource: <URI>document.uri,
+				edits: []
+			};
 
 			for (const value of values) {
 				if (Array.isArray(value) && (<vscode.TextEdit[]>value).every(e => e instanceof TextEdit)) {
 					for (const { newText, newEol, range } of value) {
-						edits.push({
-							resource: <URI>document.uri,
+						workspaceResourceEdit.edits.push({
 							range: range && fromRange(range),
 							newText,
 							newEol: EndOfLine.from(newEol)
@@ -150,12 +151,12 @@ export class ExtHostDocumentSaveParticipant implements ExtHostDocumentSavePartic
 
 			// apply edits if any and if document
 			// didn't change somehow in the meantime
-			if (edits.length === 0) {
+			if (workspaceResourceEdit.edits.length === 0) {
 				return undefined;
 			}
 
 			if (version === document.version) {
-				return this._workspace.$applyWorkspaceEdit(edits);
+				return this._mainThreadEditors.$tryApplyWorkspaceEdit([workspaceResourceEdit]);
 			}
 
 			// TODO@joh bubble this to listener?

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

@@ -729,8 +729,19 @@ class ColorProviderAdapter {
 		});
 	}
 
-	resolveColor(color: modes.IColor, colorFormat: modes.ColorFormat): TPromise<string> {
-		return asWinJsPromise(token => this._provider.resolveDocumentColor(color, colorFormat));
+	provideColorPresentations(rawColorInfo: IRawColorInfo): TPromise<modes.IColorPresentation[]> {
+		let colorInfo: vscode.ColorInformation = {
+			range: TypeConverters.toRange(rawColorInfo.range),
+			color: {
+				red: rawColorInfo.color[0],
+				green: rawColorInfo.color[1],
+				blue: rawColorInfo.color[2],
+				alpha: rawColorInfo.color[3]
+			}
+		};
+		return asWinJsPromise(token => this._provider.provideColorPresentations(colorInfo, token)).then(value => {
+			return value.map(v => TypeConverters.ColorPresentation.from(v));
+		});
 	}
 }
 
@@ -1042,8 +1053,8 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
 		return this._withAdapter(handle, ColorProviderAdapter, adapter => adapter.provideColors(resource));
 	}
 
-	$resolveDocumentColor(handle: number, color: modes.IColor, colorFormat: modes.ColorFormat): TPromise<string> {
-		return this._withAdapter(handle, ColorProviderAdapter, adapter => adapter.resolveColor(color, colorFormat));
+	$provideColorPresentations(handle: number, colorInfo: IRawColorInfo): TPromise<modes.IColorPresentation[]> {
+		return this._withAdapter(handle, ColorProviderAdapter, adapter => adapter.provideColorPresentations(colorInfo));
 	}
 
 	// --- configuration

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

@@ -118,7 +118,7 @@ namespace FileLocation {
 			case types.FileLocationKind.Absolute:
 				return { kind: Problems.FileLocationKind.Absolute };
 			case types.FileLocationKind.Relative:
-				return { kind: Problems.FileLocationKind.Relative, prefix: '${workspaceRoot}' };
+				return { kind: Problems.FileLocationKind.Relative, prefix: '${workspaceFolder}' };
 		}
 		return { kind: Problems.FileLocationKind.Auto };
 	}
@@ -348,8 +348,12 @@ namespace Tasks {
 			label: typeof task.source === 'string' ? task.source : extension.name,
 			extension: extension.id,
 			scope: scope,
-			workspaceFolder: workspaceFolder ? { uri: workspaceFolder.uri as URI } : undefined
+			workspaceFolder: undefined
 		};
+		// We can't transfer a workspace folder object from the extension host to main since they differ
+		// in shape and we don't have backwards converting function. So transfer the URI and resolve the
+		// workspace folder on the main side.
+		(source as any).__workspaceFolder = workspaceFolder ? workspaceFolder.uri as URI : undefined;
 		let label = nls.localize('task.label', '{0}: {1}', source.label, task.name);
 		let key = (task as types.Task).definitionKey;
 		let kind = (task as types.Task).definition;

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

@@ -13,7 +13,7 @@ import * as TypeConverters from './extHostTypeConverters';
 import { TextEditorDecorationType, ExtHostTextEditor } from './extHostTextEditor';
 import { ExtHostDocumentsAndEditors } from './extHostDocumentsAndEditors';
 import { Position as EditorPosition } from 'vs/platform/editor/common/editor';
-import { MainContext, MainThreadEditorsShape, ExtHostEditorsShape, ITextDocumentShowOptions, ITextEditorPositionData, IResolvedTextEditorConfiguration, ISelectionChangeEvent, IMainContext } from './extHost.protocol';
+import { MainContext, MainThreadEditorsShape, ExtHostEditorsShape, ITextDocumentShowOptions, ITextEditorPositionData, IResolvedTextEditorConfiguration, ISelectionChangeEvent, IMainContext, IWorkspaceResourceEdit } from './extHost.protocol';
 import * as vscode from 'vscode';
 
 export class ExtHostEditors implements ExtHostEditorsShape {
@@ -91,6 +91,40 @@ export class ExtHostEditors implements ExtHostEditorsShape {
 		return new TextEditorDecorationType(this._proxy, options);
 	}
 
+	applyWorkspaceEdit(edit: vscode.WorkspaceEdit): TPromise<boolean> {
+
+		let workspaceResourceEdits: IWorkspaceResourceEdit[] = [];
+
+		let entries = edit.entries();
+		for (let entry of entries) {
+			let [uri, edits] = entry;
+
+			let doc = this._extHostDocumentsAndEditors.getDocument(uri.toString());
+			let docVersion: number = undefined;
+			if (doc) {
+				docVersion = doc.version;
+			}
+
+			let workspaceResourceEdit: IWorkspaceResourceEdit = {
+				resource: <URI>uri,
+				modelVersionId: docVersion,
+				edits: []
+			};
+
+			for (let edit of edits) {
+				workspaceResourceEdit.edits.push({
+					newText: edit.newText,
+					newEol: TypeConverters.EndOfLine.from(edit.newEol),
+					range: edit.range && TypeConverters.fromRange(edit.range)
+				});
+			}
+
+			workspaceResourceEdits.push(workspaceResourceEdit);
+		}
+
+		return this._proxy.$tryApplyWorkspaceEdit(workspaceResourceEdits);
+	}
+
 	// --- called from main thread
 
 	$acceptOptionsChanged(id: string, opts: IResolvedTextEditorConfiguration): void {

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

@@ -448,6 +448,24 @@ export namespace DocumentLink {
 	}
 }
 
+export namespace ColorPresentation {
+	export function to(colorPresentation: modes.IColorPresentation): vscode.ColorPresentation {
+		return {
+			label: colorPresentation.label,
+			textEdit: colorPresentation.textEdit ? TextEdit.to(colorPresentation.textEdit) : undefined,
+			additionalTextEdits: colorPresentation.additionalTextEdits ? colorPresentation.additionalTextEdits.map(value => TextEdit.to(value)) : undefined
+		};
+	}
+
+	export function from(colorPresentation: vscode.ColorPresentation): modes.IColorPresentation {
+		return {
+			label: colorPresentation.label,
+			textEdit: colorPresentation.textEdit ? TextEdit.from(colorPresentation.textEdit) : undefined,
+			additionalTextEdits: colorPresentation.additionalTextEdits ? colorPresentation.additionalTextEdits.map(value => TextEdit.from(value)) : undefined
+		};
+	}
+}
+
 export namespace TextDocumentSaveReason {
 
 	export function to(reason: SaveReason): vscode.TextDocumentSaveReason {

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

@@ -1055,7 +1055,7 @@ export class Color {
 
 export type IColorFormat = string | { opaque: string, transparent: string };
 
-export class ColorRange {
+export class ColorInformation {
 	range: Range;
 
 	color: Color;
@@ -1072,6 +1072,12 @@ export class ColorRange {
 	}
 }
 
+export class ColorPresentation {
+	label: string;
+	textEdit?: TextEdit;
+	additionalTextEdits?: TextEdit[];
+}
+
 export enum ColorFormat {
 	RGB = 0,
 	HEX = 1,

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

@@ -10,9 +10,6 @@ import { normalize } from 'vs/base/common/paths';
 import { delta } from 'vs/base/common/arrays';
 import { relative } from 'path';
 import { Workspace } from 'vs/platform/workspace/common/workspace';
-import { IResourceEdit } from 'vs/editor/common/services/bulkEdit';
-import { TPromise } from 'vs/base/common/winjs.base';
-import { fromRange, EndOfLine } from 'vs/workbench/api/node/extHostTypeConverters';
 import { IWorkspaceData, ExtHostWorkspaceShape, MainContext, MainThreadWorkspaceShape, IMainContext } from './extHost.protocol';
 import * as vscode from 'vscode';
 import { compare } from 'vs/base/common/strings';
@@ -177,26 +174,4 @@ export class ExtHostWorkspace implements ExtHostWorkspaceShape {
 	saveAll(includeUntitled?: boolean): Thenable<boolean> {
 		return this._proxy.$saveAll(includeUntitled);
 	}
-
-	appyEdit(edit: vscode.WorkspaceEdit): TPromise<boolean> {
-
-		let resourceEdits: IResourceEdit[] = [];
-
-		let entries = edit.entries();
-		for (let entry of entries) {
-			let [uri, edits] = entry;
-
-			for (let edit of edits) {
-				resourceEdits.push({
-					resource: <URI>uri,
-					newText: edit.newText,
-					newEol: EndOfLine.from(edit.newEol),
-					range: edit.range && fromRange(edit.range)
-				});
-			}
-		}
-
-		return this._proxy.$applyWorkspaceEdit(resourceEdits);
-	}
-
 }