move mainThread[S], #70319

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

@@ -0,0 +1,438 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { Event, Emitter } from 'vs/base/common/event';
+import { assign } from 'vs/base/common/objects';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { ISCMService, ISCMRepository, ISCMProvider, ISCMResource, ISCMResourceGroup, ISCMResourceDecorations, IInputValidation } from 'vs/workbench/contrib/scm/common/scm';
+import { ExtHostContext, MainThreadSCMShape, ExtHostSCMShape, SCMProviderFeatures, SCMRawResourceSplices, SCMGroupFeatures, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { Command } from 'vs/editor/common/modes';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ISplice, Sequence } from 'vs/base/common/sequence';
+import { CancellationToken } from 'vs/base/common/cancellation';
+
+class MainThreadSCMResourceGroup implements ISCMResourceGroup {
+
+	readonly elements: ISCMResource[] = [];
+
+	private _onDidSplice = new Emitter<ISplice<ISCMResource>>();
+	readonly onDidSplice = this._onDidSplice.event;
+
+	get hideWhenEmpty(): boolean { return !!this.features.hideWhenEmpty; }
+
+	private _onDidChange = new Emitter<void>();
+	get onDidChange(): Event<void> { return this._onDidChange.event; }
+
+	constructor(
+		private readonly sourceControlHandle: number,
+		private readonly handle: number,
+		public provider: ISCMProvider,
+		public features: SCMGroupFeatures,
+		public label: string,
+		public id: string
+	) { }
+
+	toJSON(): any {
+		return {
+			$mid: 4,
+			sourceControlHandle: this.sourceControlHandle,
+			groupHandle: this.handle
+		};
+	}
+
+	splice(start: number, deleteCount: number, toInsert: ISCMResource[]) {
+		this.elements.splice(start, deleteCount, ...toInsert);
+		this._onDidSplice.fire({ start, deleteCount, toInsert });
+	}
+
+	$updateGroup(features: SCMGroupFeatures): void {
+		this.features = assign(this.features, features);
+		this._onDidChange.fire();
+	}
+
+	$updateGroupLabel(label: string): void {
+		this.label = label;
+		this._onDidChange.fire();
+	}
+}
+
+class MainThreadSCMResource implements ISCMResource {
+
+	constructor(
+		private readonly proxy: ExtHostSCMShape,
+		private readonly sourceControlHandle: number,
+		private readonly groupHandle: number,
+		private readonly handle: number,
+		public sourceUri: URI,
+		public resourceGroup: ISCMResourceGroup,
+		public decorations: ISCMResourceDecorations
+	) { }
+
+	open(): Promise<void> {
+		return this.proxy.$executeResourceCommand(this.sourceControlHandle, this.groupHandle, this.handle);
+	}
+
+	toJSON(): any {
+		return {
+			$mid: 3,
+			sourceControlHandle: this.sourceControlHandle,
+			groupHandle: this.groupHandle,
+			handle: this.handle
+		};
+	}
+}
+
+class MainThreadSCMProvider implements ISCMProvider {
+
+	private static ID_HANDLE = 0;
+	private _id = `scm${MainThreadSCMProvider.ID_HANDLE++}`;
+	get id(): string { return this._id; }
+
+	readonly groups = new Sequence<MainThreadSCMResourceGroup>();
+	private readonly _groupsByHandle: { [handle: number]: MainThreadSCMResourceGroup; } = Object.create(null);
+
+	// get groups(): ISequence<ISCMResourceGroup> {
+	// 	return {
+	// 		elements: this._groups,
+	// 		onDidSplice: this._onDidSplice.event
+	// 	};
+
+	// 	// return this._groups
+	// 	// 	.filter(g => g.resources.elements.length > 0 || !g.features.hideWhenEmpty);
+	// }
+
+	private _onDidChangeResources = new Emitter<void>();
+	get onDidChangeResources(): Event<void> { return this._onDidChangeResources.event; }
+
+	private features: SCMProviderFeatures = {};
+
+	get handle(): number { return this._handle; }
+	get label(): string { return this._label; }
+	get rootUri(): URI | undefined { return this._rootUri; }
+	get contextValue(): string { return this._contextValue; }
+
+	get commitTemplate(): string | undefined { return this.features.commitTemplate; }
+	get acceptInputCommand(): Command | undefined { return this.features.acceptInputCommand; }
+	get statusBarCommands(): Command[] | undefined { return this.features.statusBarCommands; }
+	get count(): number | undefined { return this.features.count; }
+
+	private _onDidChangeCommitTemplate = new Emitter<string>();
+	get onDidChangeCommitTemplate(): Event<string> { return this._onDidChangeCommitTemplate.event; }
+
+	private _onDidChangeStatusBarCommands = new Emitter<Command[]>();
+	get onDidChangeStatusBarCommands(): Event<Command[]> { return this._onDidChangeStatusBarCommands.event; }
+
+	private _onDidChange = new Emitter<void>();
+	get onDidChange(): Event<void> { return this._onDidChange.event; }
+
+	constructor(
+		private readonly proxy: ExtHostSCMShape,
+		private readonly _handle: number,
+		private readonly _contextValue: string,
+		private readonly _label: string,
+		private readonly _rootUri: URI | undefined,
+		@ISCMService scmService: ISCMService
+	) { }
+
+	$updateSourceControl(features: SCMProviderFeatures): void {
+		this.features = assign(this.features, features);
+		this._onDidChange.fire();
+
+		if (typeof features.commitTemplate !== 'undefined') {
+			this._onDidChangeCommitTemplate.fire(this.commitTemplate!);
+		}
+
+		if (typeof features.statusBarCommands !== 'undefined') {
+			this._onDidChangeStatusBarCommands.fire(this.statusBarCommands!);
+		}
+	}
+
+	$registerGroup(handle: number, id: string, label: string): void {
+		const group = new MainThreadSCMResourceGroup(
+			this.handle,
+			handle,
+			this,
+			{},
+			label,
+			id
+		);
+
+		this._groupsByHandle[handle] = group;
+		this.groups.splice(this.groups.elements.length, 0, [group]);
+	}
+
+	$updateGroup(handle: number, features: SCMGroupFeatures): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
+			return;
+		}
+
+		group.$updateGroup(features);
+	}
+
+	$updateGroupLabel(handle: number, label: string): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
+			return;
+		}
+
+		group.$updateGroupLabel(label);
+	}
+
+	$spliceGroupResourceStates(splices: SCMRawResourceSplices[]): void {
+		for (const [groupHandle, groupSlices] of splices) {
+			const group = this._groupsByHandle[groupHandle];
+
+			if (!group) {
+				console.warn(`SCM group ${groupHandle} not found in provider ${this.label}`);
+				continue;
+			}
+
+			// reverse the splices sequence in order to apply them correctly
+			groupSlices.reverse();
+
+			for (const [start, deleteCount, rawResources] of groupSlices) {
+				const resources = rawResources.map(rawResource => {
+					const [handle, sourceUri, icons, tooltip, strikeThrough, faded, source, letter, color] = rawResource;
+					const icon = icons[0];
+					const iconDark = icons[1] || icon;
+					const decorations = {
+						icon: icon ? URI.parse(icon) : undefined,
+						iconDark: iconDark ? URI.parse(iconDark) : undefined,
+						tooltip,
+						strikeThrough,
+						faded,
+						source,
+						letter,
+						color: color ? color.id : undefined
+					};
+
+					return new MainThreadSCMResource(
+						this.proxy,
+						this.handle,
+						groupHandle,
+						handle,
+						URI.revive(sourceUri),
+						group,
+						decorations
+					);
+				});
+
+				group.splice(start, deleteCount, resources);
+			}
+		}
+
+		this._onDidChangeResources.fire();
+	}
+
+	$unregisterGroup(handle: number): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
+			return;
+		}
+
+		delete this._groupsByHandle[handle];
+		this.groups.splice(this.groups.elements.indexOf(group), 1);
+	}
+
+	async getOriginalResource(uri: URI): Promise<URI | null> {
+		if (!this.features.hasQuickDiffProvider) {
+			return null;
+		}
+
+		const result = await this.proxy.$provideOriginalResource(this.handle, uri, CancellationToken.None);
+		return result && URI.revive(result);
+	}
+
+	toJSON(): any {
+		return {
+			$mid: 5,
+			handle: this.handle
+		};
+	}
+
+	dispose(): void {
+
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadSCM)
+export class MainThreadSCM implements MainThreadSCMShape {
+
+	private readonly _proxy: ExtHostSCMShape;
+	private _repositories: { [handle: number]: ISCMRepository; } = Object.create(null);
+	private _inputDisposables: { [handle: number]: IDisposable; } = Object.create(null);
+	private _disposables: IDisposable[] = [];
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ISCMService private readonly scmService: ISCMService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostSCM);
+
+		Event.debounce(scmService.onDidChangeSelectedRepositories, (_, e) => e, 100)
+			(this.onDidChangeSelectedRepositories, this, this._disposables);
+	}
+
+	dispose(): void {
+		Object.keys(this._repositories)
+			.forEach(id => this._repositories[id].dispose());
+		this._repositories = Object.create(null);
+
+		Object.keys(this._inputDisposables)
+			.forEach(id => this._inputDisposables[id].dispose());
+		this._inputDisposables = Object.create(null);
+
+		this._disposables = dispose(this._disposables);
+	}
+
+	$registerSourceControl(handle: number, id: string, label: string, rootUri: UriComponents | undefined): void {
+		const provider = new MainThreadSCMProvider(this._proxy, handle, id, label, rootUri && URI.revive(rootUri), this.scmService);
+		const repository = this.scmService.registerSCMProvider(provider);
+		this._repositories[handle] = repository;
+
+		const inputDisposable = repository.input.onDidChange(value => this._proxy.$onInputBoxValueChange(handle, value));
+		this._inputDisposables[handle] = inputDisposable;
+	}
+
+	$updateSourceControl(handle: number, features: SCMProviderFeatures): void {
+		const repository = this._repositories[handle];
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$updateSourceControl(features);
+	}
+
+	$unregisterSourceControl(handle: number): void {
+		const repository = this._repositories[handle];
+
+		if (!repository) {
+			return;
+		}
+
+		this._inputDisposables[handle].dispose();
+		delete this._inputDisposables[handle];
+
+		repository.dispose();
+		delete this._repositories[handle];
+	}
+
+	$registerGroup(sourceControlHandle: number, groupHandle: number, id: string, label: string): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$registerGroup(groupHandle, id, label);
+	}
+
+	$updateGroup(sourceControlHandle: number, groupHandle: number, features: SCMGroupFeatures): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$updateGroup(groupHandle, features);
+	}
+
+	$updateGroupLabel(sourceControlHandle: number, groupHandle: number, label: string): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$updateGroupLabel(groupHandle, label);
+	}
+
+	$spliceResourceStates(sourceControlHandle: number, splices: SCMRawResourceSplices[]): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$spliceGroupResourceStates(splices);
+	}
+
+	$unregisterGroup(sourceControlHandle: number, handle: number): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$unregisterGroup(handle);
+	}
+
+	$setInputBoxValue(sourceControlHandle: number, value: string): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		repository.input.value = value;
+	}
+
+	$setInputBoxPlaceholder(sourceControlHandle: number, placeholder: string): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		repository.input.placeholder = placeholder;
+	}
+
+	$setInputBoxVisibility(sourceControlHandle: number, visible: boolean): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		repository.input.visible = visible;
+	}
+
+	$setValidationProviderIsEnabled(sourceControlHandle: number, enabled: boolean): void {
+		const repository = this._repositories[sourceControlHandle];
+
+		if (!repository) {
+			return;
+		}
+
+		if (enabled) {
+			repository.input.validateInput = async (value, pos): Promise<IInputValidation | undefined> => {
+				const result = await this._proxy.$validateInput(sourceControlHandle, value, pos);
+				return result && { message: result[0], type: result[1] };
+			};
+		} else {
+			repository.input.validateInput = async () => undefined;
+		}
+	}
+
+	private onDidChangeSelectedRepositories(repositories: ISCMRepository[]): void {
+		const handles = repositories
+			.filter(r => r.provider instanceof MainThreadSCMProvider)
+			.map(r => (r.provider as MainThreadSCMProvider).handle);
+
+		this._proxy.$setSelectedSourceControls(handles);
+	}
+}

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

@@ -0,0 +1,436 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { isNonEmptyArray } from 'vs/base/common/arrays';
+import { IdleValue, sequence } from 'vs/base/common/async';
+import { CancellationTokenSource, CancellationToken } from 'vs/base/common/cancellation';
+import * as strings from 'vs/base/common/strings';
+import { ICodeEditor, IActiveCodeEditor } from 'vs/editor/browser/editorBrowser';
+import { IBulkEditService } from 'vs/editor/browser/services/bulkEditService';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { trimTrailingWhitespace } from 'vs/editor/common/commands/trimTrailingWhitespaceCommand';
+import { ICodeActionsOnSaveOptions } from 'vs/editor/common/config/editorOptions';
+import { EditOperation } from 'vs/editor/common/core/editOperation';
+import { Position } from 'vs/editor/common/core/position';
+import { Range } from 'vs/editor/common/core/range';
+import { Selection } from 'vs/editor/common/core/selection';
+import { IIdentifiedSingleEditOperation, ITextModel } from 'vs/editor/common/model';
+import { CodeAction, TextEdit } from 'vs/editor/common/modes';
+import { IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
+import { shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
+import { getCodeActions } from 'vs/editor/contrib/codeAction/codeAction';
+import { applyCodeAction } from 'vs/editor/contrib/codeAction/codeActionCommands';
+import { CodeActionKind } from 'vs/editor/contrib/codeAction/codeActionTrigger';
+import { getDocumentFormattingEdits, FormatMode } from 'vs/editor/contrib/format/format';
+import { FormattingEdit } from 'vs/editor/contrib/format/formattingEdit';
+import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
+import { localize } from 'vs/nls';
+import { ICommandService } from 'vs/platform/commands/common/commands';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IProgressService2, ProgressLocation } from 'vs/platform/progress/common/progress';
+import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { TextFileEditorModel } from 'vs/workbench/services/textfile/common/textFileEditorModel';
+import { ISaveParticipant, SaveReason, IResolvedTextFileEditorModel } from 'vs/workbench/services/textfile/common/textfiles';
+import { ExtHostContext, ExtHostDocumentSaveParticipantShape, IExtHostContext } from '../common/extHost.protocol';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+
+export interface ISaveParticipantParticipant extends ISaveParticipant {
+	// progressMessage: string;
+}
+
+class TrimWhitespaceParticipant implements ISaveParticipantParticipant {
+
+	constructor(
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@ICodeEditorService private readonly codeEditorService: ICodeEditorService
+	) {
+		// Nothing
+	}
+
+	async participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+		if (this.configurationService.getValue('files.trimTrailingWhitespace', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
+			this.doTrimTrailingWhitespace(model.textEditorModel, env.reason === SaveReason.AUTO);
+		}
+	}
+
+	private doTrimTrailingWhitespace(model: ITextModel, isAutoSaved: boolean): void {
+		let prevSelection: Selection[] = [];
+		let cursors: Position[] = [];
+
+		const editor = findEditor(model, this.codeEditorService);
+		if (editor) {
+			// Find `prevSelection` in any case do ensure a good undo stack when pushing the edit
+			// Collect active cursors in `cursors` only if `isAutoSaved` to avoid having the cursors jump
+			prevSelection = editor.getSelections();
+			if (isAutoSaved) {
+				cursors = prevSelection.map(s => s.getPosition());
+				const snippetsRange = SnippetController2.get(editor).getSessionEnclosingRange();
+				if (snippetsRange) {
+					for (let lineNumber = snippetsRange.startLineNumber; lineNumber <= snippetsRange.endLineNumber; lineNumber++) {
+						cursors.push(new Position(lineNumber, model.getLineMaxColumn(lineNumber)));
+					}
+				}
+			}
+		}
+
+		const ops = trimTrailingWhitespace(model, cursors);
+		if (!ops.length) {
+			return; // Nothing to do
+		}
+
+		model.pushEditOperations(prevSelection, ops, (edits) => prevSelection);
+	}
+}
+
+function findEditor(model: ITextModel, codeEditorService: ICodeEditorService): IActiveCodeEditor | null {
+	let candidate: IActiveCodeEditor | null = null;
+
+	if (model.isAttachedToEditor()) {
+		for (const editor of codeEditorService.listCodeEditors()) {
+			if (editor.hasModel() && editor.getModel() === model) {
+				if (editor.hasTextFocus()) {
+					return editor; // favour focused editor if there are multiple
+				}
+
+				candidate = editor;
+			}
+		}
+	}
+
+	return candidate;
+}
+
+export class FinalNewLineParticipant implements ISaveParticipantParticipant {
+
+	constructor(
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@ICodeEditorService private readonly codeEditorService: ICodeEditorService
+	) {
+		// Nothing
+	}
+
+	async participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+		if (this.configurationService.getValue('files.insertFinalNewline', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
+			this.doInsertFinalNewLine(model.textEditorModel);
+		}
+	}
+
+	private doInsertFinalNewLine(model: ITextModel): void {
+		const lineCount = model.getLineCount();
+		const lastLine = model.getLineContent(lineCount);
+		const lastLineIsEmptyOrWhitespace = strings.lastNonWhitespaceIndex(lastLine) === -1;
+
+		if (!lineCount || lastLineIsEmptyOrWhitespace) {
+			return;
+		}
+
+		let prevSelection: Selection[] = [];
+		const editor = findEditor(model, this.codeEditorService);
+		if (editor) {
+			prevSelection = editor.getSelections();
+		}
+
+		model.pushEditOperations(prevSelection, [EditOperation.insert(new Position(lineCount, model.getLineMaxColumn(lineCount)), model.getEOL())], edits => prevSelection);
+
+		if (editor) {
+			editor.setSelections(prevSelection);
+		}
+	}
+}
+
+export class TrimFinalNewLinesParticipant implements ISaveParticipantParticipant {
+
+	constructor(
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@ICodeEditorService private readonly codeEditorService: ICodeEditorService
+	) {
+		// Nothing
+	}
+
+	async participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+		if (this.configurationService.getValue('files.trimFinalNewlines', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
+			this.doTrimFinalNewLines(model.textEditorModel, env.reason === SaveReason.AUTO);
+		}
+	}
+
+	/**
+	 * returns 0 if the entire file is empty or whitespace only
+	 */
+	private findLastLineWithContent(model: ITextModel): number {
+		for (let lineNumber = model.getLineCount(); lineNumber >= 1; lineNumber--) {
+			const lineContent = model.getLineContent(lineNumber);
+			if (strings.lastNonWhitespaceIndex(lineContent) !== -1) {
+				// this line has content
+				return lineNumber;
+			}
+		}
+		// no line has content
+		return 0;
+	}
+
+	private doTrimFinalNewLines(model: ITextModel, isAutoSaved: boolean): void {
+		const lineCount = model.getLineCount();
+
+		// Do not insert new line if file does not end with new line
+		if (lineCount === 1) {
+			return;
+		}
+
+		let prevSelection: Selection[] = [];
+		let cannotTouchLineNumber = 0;
+		const editor = findEditor(model, this.codeEditorService);
+		if (editor) {
+			prevSelection = editor.getSelections();
+			if (isAutoSaved) {
+				for (let i = 0, len = prevSelection.length; i < len; i++) {
+					const positionLineNumber = prevSelection[i].positionLineNumber;
+					if (positionLineNumber > cannotTouchLineNumber) {
+						cannotTouchLineNumber = positionLineNumber;
+					}
+				}
+			}
+		}
+
+		const lastLineNumberWithContent = this.findLastLineWithContent(model);
+		const deleteFromLineNumber = Math.max(lastLineNumberWithContent + 1, cannotTouchLineNumber + 1);
+		const deletionRange = model.validateRange(new Range(deleteFromLineNumber, 1, lineCount, model.getLineMaxColumn(lineCount)));
+
+		if (deletionRange.isEmpty()) {
+			return;
+		}
+
+		model.pushEditOperations(prevSelection, [EditOperation.delete(deletionRange)], edits => prevSelection);
+
+		if (editor) {
+			editor.setSelections(prevSelection);
+		}
+	}
+}
+
+class FormatOnSaveParticipant implements ISaveParticipantParticipant {
+
+	constructor(
+		@ICodeEditorService private readonly _editorService: ICodeEditorService,
+		@IEditorWorkerService private readonly _editorWorkerService: IEditorWorkerService,
+		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+	) {
+		// Nothing
+	}
+
+	async participate(editorModel: IResolvedTextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+
+		const model = editorModel.textEditorModel;
+		if (env.reason === SaveReason.AUTO
+			|| !this._configurationService.getValue('editor.formatOnSave', { overrideIdentifier: model.getLanguageIdentifier().language, resource: editorModel.getResource() })) {
+			return undefined;
+		}
+
+		const versionNow = model.getVersionId();
+
+		const timeout = this._configurationService.getValue<number>('editor.formatOnSaveTimeout', { overrideIdentifier: model.getLanguageIdentifier().language, resource: editorModel.getResource() });
+
+		return new Promise<TextEdit[] | null | undefined>((resolve, reject) => {
+			const source = new CancellationTokenSource();
+			const request = getDocumentFormattingEdits(this._telemetryService, this._editorWorkerService, model, model.getFormattingOptions(), FormatMode.Auto, source.token);
+
+			setTimeout(() => {
+				reject(localize('timeout.formatOnSave', "Aborted format on save after {0}ms", timeout));
+				source.cancel();
+			}, timeout);
+
+			request.then(resolve, reject);
+
+		}).then(edits => {
+			if (isNonEmptyArray(edits) && versionNow === model.getVersionId()) {
+				const editor = findEditor(model, this._editorService);
+				if (editor) {
+					this._editsWithEditor(editor, edits);
+				} else {
+					this._editWithModel(model, edits);
+				}
+			}
+		});
+	}
+
+	private _editsWithEditor(editor: ICodeEditor, edits: TextEdit[]): void {
+		FormattingEdit.execute(editor, edits);
+	}
+
+	private _editWithModel(model: ITextModel, edits: TextEdit[]): void {
+
+		const [{ range }] = edits;
+		const initialSelection = new Selection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);
+
+		model.pushEditOperations([initialSelection], edits.map(FormatOnSaveParticipant._asIdentEdit), undoEdits => {
+			for (const { range } of undoEdits) {
+				if (Range.areIntersectingOrTouching(range, initialSelection)) {
+					return [new Selection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn)];
+				}
+			}
+			return null;
+		});
+	}
+
+	private static _asIdentEdit({ text, range }: TextEdit): IIdentifiedSingleEditOperation {
+		return {
+			text,
+			range: Range.lift(range),
+			forceMoveMarkers: true
+		};
+	}
+}
+
+class CodeActionOnSaveParticipant implements ISaveParticipant {
+
+	constructor(
+		@IBulkEditService private readonly _bulkEditService: IBulkEditService,
+		@ICommandService private readonly _commandService: ICommandService,
+		@IConfigurationService private readonly _configurationService: IConfigurationService
+	) { }
+
+	async participate(editorModel: IResolvedTextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+		if (env.reason === SaveReason.AUTO) {
+			return undefined;
+		}
+
+		const model = editorModel.textEditorModel;
+
+		const settingsOverrides = { overrideIdentifier: model.getLanguageIdentifier().language, resource: editorModel.getResource() };
+		const setting = this._configurationService.getValue<ICodeActionsOnSaveOptions>('editor.codeActionsOnSave', settingsOverrides);
+		if (!setting) {
+			return undefined;
+		}
+
+		const codeActionsOnSave = Object.keys(setting)
+			.filter(x => setting[x]).map(x => new CodeActionKind(x))
+			.sort((a, b) => {
+				if (a.value === CodeActionKind.SourceFixAll.value) {
+					return -1;
+				}
+				if (b.value === CodeActionKind.SourceFixAll.value) {
+					return 1;
+				}
+				return 0;
+			});
+		if (!codeActionsOnSave.length) {
+			return undefined;
+		}
+
+		const tokenSource = new CancellationTokenSource();
+
+		const timeout = this._configurationService.getValue<number>('editor.codeActionsOnSaveTimeout', settingsOverrides);
+
+		return Promise.race([
+			new Promise<void>((_resolve, reject) =>
+				setTimeout(() => {
+					tokenSource.cancel();
+					reject(localize('codeActionsOnSave.didTimeout', "Aborted codeActionsOnSave after {0}ms", timeout));
+				}, timeout)),
+			this.applyOnSaveActions(model, codeActionsOnSave, tokenSource.token)
+		]).then(() => {
+			tokenSource.cancel();
+		}, (e) => {
+			tokenSource.cancel();
+			return Promise.reject(e);
+		});
+	}
+
+	private async applyOnSaveActions(model: ITextModel, codeActionsOnSave: CodeActionKind[], token: CancellationToken): Promise<void> {
+		for (const codeActionKind of codeActionsOnSave) {
+			const actionsToRun = await this.getActionsToRun(model, codeActionKind, token);
+			try {
+				await this.applyCodeActions(actionsToRun.actions);
+			} catch {
+				// Failure to apply a code action should not block other on save actions
+			}
+		}
+	}
+
+	private async applyCodeActions(actionsToRun: ReadonlyArray<CodeAction>) {
+		for (const action of actionsToRun) {
+			await applyCodeAction(action, this._bulkEditService, this._commandService);
+		}
+	}
+
+	private getActionsToRun(model: ITextModel, codeActionKind: CodeActionKind, token: CancellationToken) {
+		return getCodeActions(model, model.getFullModelRange(), {
+			type: 'auto',
+			filter: { kind: codeActionKind, includeSourceActions: true },
+		}, token);
+	}
+}
+
+class ExtHostSaveParticipant implements ISaveParticipantParticipant {
+
+	private readonly _proxy: ExtHostDocumentSaveParticipantShape;
+
+	constructor(extHostContext: IExtHostContext) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant);
+	}
+
+	async participate(editorModel: IResolvedTextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+
+		if (!shouldSynchronizeModel(editorModel.textEditorModel)) {
+			// the model never made it to the extension
+			// host meaning we cannot participate in its save
+			return undefined;
+		}
+
+		return new Promise<any>((resolve, reject) => {
+			setTimeout(() => reject(localize('timeout.onWillSave', "Aborted onWillSaveTextDocument-event after 1750ms")), 1750);
+			this._proxy.$participateInSave(editorModel.getResource(), env.reason).then(values => {
+				for (const success of values) {
+					if (!success) {
+						return Promise.reject(new Error('listener failed'));
+					}
+				}
+				return undefined;
+			}).then(resolve, reject);
+		});
+	}
+}
+
+// The save participant can change a model before its saved to support various scenarios like trimming trailing whitespace
+@extHostCustomer
+export class SaveParticipant implements ISaveParticipant {
+
+	private readonly _saveParticipants: IdleValue<ISaveParticipantParticipant[]>;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IInstantiationService instantiationService: IInstantiationService,
+		@IProgressService2 private readonly _progressService: IProgressService2,
+		@ILogService private readonly _logService: ILogService
+	) {
+		this._saveParticipants = new IdleValue(() => [
+			instantiationService.createInstance(TrimWhitespaceParticipant),
+			instantiationService.createInstance(CodeActionOnSaveParticipant),
+			instantiationService.createInstance(FormatOnSaveParticipant),
+			instantiationService.createInstance(FinalNewLineParticipant),
+			instantiationService.createInstance(TrimFinalNewLinesParticipant),
+			instantiationService.createInstance(ExtHostSaveParticipant, extHostContext),
+		]);
+		// Hook into model
+		TextFileEditorModel.setSaveParticipant(this);
+	}
+
+	dispose(): void {
+		TextFileEditorModel.setSaveParticipant(null);
+		this._saveParticipants.dispose();
+	}
+
+	async participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+		return this._progressService.withProgress({ location: ProgressLocation.Window }, progress => {
+			progress.report({ message: localize('saveParticipants', "Running Save Participants...") });
+			const promiseFactory = this._saveParticipants.getValue().map(p => () => {
+				return p.participate(model, env);
+			});
+			return sequence(promiseFactory).then(() => { }, err => this._logService.warn(err));
+		});
+	}
+}

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

@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { values } from 'vs/base/common/map';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IFileMatch, IFileQuery, IRawFileMatch2, ISearchComplete, ISearchCompleteStats, ISearchProgressItem, ISearchResultProvider, ISearchService, ITextQuery, QueryType, SearchProviderType } from 'vs/workbench/services/search/common/search';
+import { ExtHostContext, ExtHostSearchShape, IExtHostContext, MainContext, MainThreadSearchShape } from '../common/extHost.protocol';
+
+@extHostNamedCustomer(MainContext.MainThreadSearch)
+export class MainThreadSearch implements MainThreadSearchShape {
+
+	private readonly _proxy: ExtHostSearchShape;
+	private readonly _searchProvider = new Map<number, RemoteSearchProvider>();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ISearchService private readonly _searchService: ISearchService,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostSearch);
+	}
+
+	dispose(): void {
+		this._searchProvider.forEach(value => value.dispose());
+		this._searchProvider.clear();
+	}
+
+	$registerTextSearchProvider(handle: number, scheme: string): void {
+		this._searchProvider.set(handle, new RemoteSearchProvider(this._searchService, SearchProviderType.text, scheme, handle, this._proxy));
+	}
+
+	$registerFileSearchProvider(handle: number, scheme: string): void {
+		this._searchProvider.set(handle, new RemoteSearchProvider(this._searchService, SearchProviderType.file, scheme, handle, this._proxy));
+	}
+
+	$unregisterProvider(handle: number): void {
+		dispose(this._searchProvider.get(handle));
+		this._searchProvider.delete(handle);
+	}
+
+	$handleFileMatch(handle: number, session, data: UriComponents[]): void {
+		const provider = this._searchProvider.get(handle);
+		if (!provider) {
+			throw new Error('Got result for unknown provider');
+		}
+
+		provider.handleFindMatch(session, data);
+	}
+
+	$handleTextMatch(handle: number, session, data: IRawFileMatch2[]): void {
+		const provider = this._searchProvider.get(handle);
+		if (!provider) {
+			throw new Error('Got result for unknown provider');
+		}
+
+		provider.handleFindMatch(session, data);
+	}
+
+	$handleTelemetry(eventName: string, data: any): void {
+		this._telemetryService.publicLog(eventName, data);
+	}
+}
+
+class SearchOperation {
+
+	private static _idPool = 0;
+
+	constructor(
+		readonly progress?: (match: IFileMatch) => any,
+		readonly id: number = ++SearchOperation._idPool,
+		readonly matches = new Map<string, IFileMatch>()
+	) {
+		//
+	}
+
+	addMatch(match: IFileMatch): void {
+		if (this.matches.has(match.resource.toString())) {
+			// Merge with previous IFileMatches
+			// TODO@rob clean up text/file result types
+			this.matches.get(match.resource.toString())!.results!.push(...match.results!);
+		} else {
+			this.matches.set(match.resource.toString(), match);
+		}
+
+		if (this.progress) {
+			this.progress(match);
+		}
+	}
+}
+
+class RemoteSearchProvider implements ISearchResultProvider, IDisposable {
+
+	private readonly _registrations: IDisposable[];
+	private readonly _searches = new Map<number, SearchOperation>();
+
+	constructor(
+		searchService: ISearchService,
+		type: SearchProviderType,
+		private readonly _scheme: string,
+		private readonly _handle: number,
+		private readonly _proxy: ExtHostSearchShape
+	) {
+		this._registrations = [searchService.registerSearchResultProvider(this._scheme, type, this)];
+	}
+
+	dispose(): void {
+		dispose(this._registrations);
+	}
+
+	fileSearch(query: IFileQuery, token: CancellationToken = CancellationToken.None): Promise<ISearchComplete> {
+		return this.doSearch(query, undefined, token);
+	}
+
+	textSearch(query: ITextQuery, onProgress?: (p: ISearchProgressItem) => void, token: CancellationToken = CancellationToken.None): Promise<ISearchComplete> {
+		return this.doSearch(query, onProgress, token);
+	}
+
+	doSearch(query: ITextQuery | IFileQuery, onProgress?: (p: ISearchProgressItem) => void, token: CancellationToken = CancellationToken.None): Promise<ISearchComplete> {
+		if (!query.folderQueries.length) {
+			throw new Error('Empty folderQueries');
+		}
+
+		const search = new SearchOperation(onProgress);
+		this._searches.set(search.id, search);
+
+		const searchP = query.type === QueryType.File
+			? this._proxy.$provideFileSearchResults(this._handle, search.id, query, token)
+			: this._proxy.$provideTextSearchResults(this._handle, search.id, query, token);
+
+		return Promise.resolve(searchP).then((result: ISearchCompleteStats) => {
+			this._searches.delete(search.id);
+			return { results: values(search.matches), stats: result.stats, limitHit: result.limitHit };
+		}, err => {
+			this._searches.delete(search.id);
+			return Promise.reject(err);
+		});
+	}
+
+	clearCache(cacheKey: string): Promise<void> {
+		return Promise.resolve(this._proxy.$clearCache(cacheKey));
+	}
+
+	handleFindMatch(session: number, dataOrUri: Array<UriComponents | IRawFileMatch2>): void {
+		const searchOp = this._searches.get(session);
+
+		if (!searchOp) {
+			// ignore...
+			return;
+		}
+
+		dataOrUri.forEach(result => {
+			if ((<IRawFileMatch2>result).results) {
+				searchOp.addMatch({
+					resource: URI.revive((<IRawFileMatch2>result).resource),
+					results: (<IRawFileMatch2>result).results
+				});
+			} else {
+				searchOp.addMatch({
+					resource: URI.revive(result)
+				});
+			}
+		});
+	}
+}

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

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IStatusbarService, StatusbarAlignment as MainThreadStatusBarAlignment } from 'vs/platform/statusbar/common/statusbar';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { MainThreadStatusBarShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { ThemeColor } from 'vs/platform/theme/common/themeService';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+
+@extHostNamedCustomer(MainContext.MainThreadStatusBar)
+export class MainThreadStatusBar implements MainThreadStatusBarShape {
+
+	private readonly _entries: { [id: number]: IDisposable };
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IStatusbarService private readonly _statusbarService: IStatusbarService
+	) {
+		this._entries = Object.create(null);
+	}
+
+	dispose(): void {
+		for (const key in this._entries) {
+			this._entries[key].dispose();
+		}
+	}
+
+	$setEntry(id: number, extensionId: ExtensionIdentifier, text: string, tooltip: string, command: string, color: string | ThemeColor, alignment: MainThreadStatusBarAlignment, priority: number): void {
+
+		// Dispose any old
+		this.$dispose(id);
+
+		// Add new
+		const entry = this._statusbarService.addEntry({ text, tooltip, command, color, extensionId }, alignment, priority);
+		this._entries[id] = entry;
+	}
+
+	$dispose(id: number) {
+		const disposeable = this._entries[id];
+		if (disposeable) {
+			disposeable.dispose();
+		}
+
+		delete this._entries[id];
+	}
+}

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

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import { MainThreadStorageShape, MainContext, IExtHostContext, ExtHostStorageShape, ExtHostContext } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IDisposable } from 'vs/base/common/lifecycle';
+
+@extHostNamedCustomer(MainContext.MainThreadStorage)
+export class MainThreadStorage implements MainThreadStorageShape {
+
+	private readonly _storageService: IStorageService;
+	private readonly _proxy: ExtHostStorageShape;
+	private readonly _storageListener: IDisposable;
+	private readonly _sharedStorageKeysToWatch: Map<string, boolean> = new Map<string, boolean>();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IStorageService storageService: IStorageService
+	) {
+		this._storageService = storageService;
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostStorage);
+
+		this._storageListener = this._storageService.onDidChangeStorage(e => {
+			const shared = e.scope === StorageScope.GLOBAL;
+			if (shared && this._sharedStorageKeysToWatch.has(e.key)) {
+				try {
+					this._proxy.$acceptValue(shared, e.key, this._getValue(shared, e.key));
+				} catch (error) {
+					// ignore parsing errors that can happen
+				}
+			}
+		});
+	}
+
+	dispose(): void {
+		this._storageListener.dispose();
+	}
+
+	$getValue<T>(shared: boolean, key: string): Promise<T | undefined> {
+		if (shared) {
+			this._sharedStorageKeysToWatch.set(key, true);
+		}
+		try {
+			return Promise.resolve(this._getValue<T>(shared, key));
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	private _getValue<T>(shared: boolean, key: string): T | undefined {
+		const jsonValue = this._storageService.get(key, shared ? StorageScope.GLOBAL : StorageScope.WORKSPACE);
+		if (!jsonValue) {
+			return undefined;
+		}
+		return JSON.parse(jsonValue);
+	}
+
+	$setValue(shared: boolean, key: string, value: object): Promise<void> {
+		let jsonValue: string;
+		try {
+			jsonValue = JSON.stringify(value);
+			this._storageService.store(key, jsonValue, shared ? StorageScope.GLOBAL : StorageScope.WORKSPACE);
+		} catch (err) {
+			return Promise.reject(err);
+		}
+		return Promise.resolve(undefined);
+	}
+}