editors - allow to apply empty working set (microsoft#210167)

Author: bpasero

src/vs/workbench/browser/parts/editor/editorPart.ts

@@ -1342,16 +1342,16 @@ export class EditorPart extends Part implements IEditorPart, IEditorGroupsView {
 		};
 	}
 
-	async applyState(state: IEditorPartUIState): Promise<void> {
-
-		// Before disposing groups, try to close as many editors as
-		// possible, but skip over those that would trigger a dialog
-		// (for example when being dirty). This is to be able to later
-		// restore these editors after state has been applied.
-		const groups = this.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE);
-		for (const group of groups) {
-			await group.closeAllEditors({ excludeConfirming: true });
+	applyState(state: IEditorPartUIState | 'empty'): Promise<void> {
+		if (state === 'empty') {
+			return this.doApplyEmptyState();
+		} else {
+			return this.doApplyState(state);
 		}
+	}
+
+	private async doApplyState(state: IEditorPartUIState): Promise<void> {
+		const groups = await this.doPrepareApplyState();
 		const resumeEvents = this.disposeGroups(true /* suspress events for the duration of applying state */);
 
 		// MRU
@@ -1375,6 +1375,27 @@ export class EditorPart extends Part implements IEditorPart, IEditorGroupsView {
 		);
 	}
 
+	private async doApplyEmptyState(): Promise<void> {
+		await this.doPrepareApplyState();
+
+		this.mergeAllGroups(this.activeGroup);
+	}
+
+	private async doPrepareApplyState(): Promise<IEditorGroupView[]> {
+
+		// Before disposing groups, try to close as many editors as
+		// possible, but skip over those that would trigger a dialog
+		// (for example when being dirty). This is to be able to later
+		// restore these editors after state has been applied.
+
+		const groups = this.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE);
+		for (const group of groups) {
+			await group.closeAllEditors({ excludeConfirming: true });
+		}
+
+		return groups;
+	}
+
 	private doApplyGridState(gridState: ISerializedGrid, activeGroupId: GroupIdentifier, editorGroupViewsToReuse?: IEditorGroupView[]): void {
 
 		// Recreate grid widget from state

src/vs/workbench/browser/parts/editor/editorParts.ts

@@ -296,12 +296,13 @@ export class EditorParts extends MultiWindowParts<EditorPart> implements IEditor
 		}
 	}
 
-	private async applyState(state: IEditorPartsUIState): Promise<boolean> {
+	private async applyState(state: IEditorPartsUIState | 'empty'): Promise<boolean> {
 
 		// Before closing windows, try to close as many editors as
 		// possible, but skip over those that would trigger a dialog
 		// (for example when being dirty). This is to be able to have
 		// them merge into the main part.
+
 		for (const part of this.parts) {
 			if (part === this.mainPart) {
 				continue; // main part takes care on its own
@@ -317,8 +318,10 @@ export class EditorParts extends MultiWindowParts<EditorPart> implements IEditor
 			}
 		}
 
-		// Restore auxiliary state
-		await this.restoreState(state);
+		// Restore auxiliary state unless we are in an empty state
+		if (state !== 'empty') {
+			await this.restoreState(state);
+		}
 
 		return true;
 	}
@@ -369,8 +372,14 @@ export class EditorParts extends MultiWindowParts<EditorPart> implements IEditor
 		}
 	}
 
-	async applyWorkingSet(workingSet: IEditorWorkingSet): Promise<boolean> {
-		const workingSetState = this.editorWorkingSets[this.indexOfWorkingSet(workingSet) ?? -1];
+	async applyWorkingSet(workingSet: IEditorWorkingSet | 'empty'): Promise<boolean> {
+		let workingSetState: IEditorWorkingSetState | 'empty' | undefined;
+		if (workingSet === 'empty') {
+			workingSetState = 'empty';
+		} else {
+			workingSetState = this.editorWorkingSets[this.indexOfWorkingSet(workingSet) ?? -1];
+		}
+
 		if (!workingSetState) {
 			return false;
 		}
@@ -379,11 +388,11 @@ export class EditorParts extends MultiWindowParts<EditorPart> implements IEditor
 		// editors around that need confirmation by moving them into the main part.
 		// Also, in rare cases, the auxiliary part may not be able to apply the state
 		// for certain editors that cannot move to the main part.
-		const applied = await this.applyState(workingSetState.auxiliary);
+		const applied = await this.applyState(workingSetState === 'empty' ? workingSetState : workingSetState.auxiliary);
 		if (!applied) {
 			return false;
 		}
-		await this.mainPart.applyState(workingSetState.main);
+		await this.mainPart.applyState(workingSetState === 'empty' ? workingSetState : workingSetState.main);
 
 		// Restore Focus
 		const mostRecentActivePart = firstOrDefault(this.mostRecentActiveParts);

src/vs/workbench/contrib/scm/browser/workingSet.ts

@@ -5,19 +5,13 @@
 
 import { Event } from 'vs/base/common/event';
 import { DisposableMap, DisposableStore } from 'vs/base/common/lifecycle';
-import { Schemas } from 'vs/base/common/network';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
 import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
-import { EditorInput } from 'vs/workbench/common/editor/editorInput';
 import { getProviderKey } from 'vs/workbench/contrib/scm/browser/util';
 import { ISCMRepository, ISCMService } from 'vs/workbench/contrib/scm/common/scm';
 import { IEditorGroupsService, IEditorWorkingSet } from 'vs/workbench/services/editor/common/editorGroupsService';
 
-function workingSetEditorFilter(editor: EditorInput): boolean {
-	return editor.resource?.scheme !== Schemas.untitled && !editor.isDirty();
-}
-
 type ISCMSerializedWorkingSet = {
 	readonly providerKey: string;
 	readonly currentHistoryItemGroupId: string;
@@ -147,13 +141,13 @@ export class SCMWorkingSetController implements IWorkbenchContribution {
 			return;
 		}
 
-		const editorWorkingSetId = workingSets.editorWorkingSets.get(currentHistoryItemGroupId);
+		let editorWorkingSetId: IEditorWorkingSet | 'empty' | undefined = workingSets.editorWorkingSets.get(currentHistoryItemGroupId);
+		if (!editorWorkingSetId && this.configurationService.getValue<'empty' | 'current'>('scm.workingSets.default') === 'empty') {
+			editorWorkingSetId = 'empty';
+		}
+
 		if (editorWorkingSetId) {
 			await this.editorGroupsService.applyWorkingSet(editorWorkingSetId);
-		} else if (this.configurationService.getValue<'empty' | 'current'>('scm.workingSets.default') === 'empty') {
-			await Promise.all(this.editorGroupsService.groups.map(group => {
-				return group.closeEditors(group.editors.filter(workingSetEditorFilter));
-			}));
 		}
 	}
 

src/vs/workbench/services/editor/common/editorGroupsService.ts

@@ -551,11 +551,11 @@ export interface IEditorGroupsService extends IEditorGroupsContainer {
 	getWorkingSets(): IEditorWorkingSet[];
 
 	/**
-	 * Applies the working set.
+	 * Applies the working set. Use `empty` to apply an empty working set.
 	 *
 	 * @returns `true` when the working set as applied.
 	 */
-	applyWorkingSet(workingSet: IEditorWorkingSet): Promise<boolean>;
+	applyWorkingSet(workingSet: IEditorWorkingSet | 'empty'): Promise<boolean>;
 
 	/**
 	 * Deletes a working set.

src/vs/workbench/services/editor/test/browser/editorGroupsService.test.ts

@@ -6,7 +6,7 @@
 import * as assert from 'assert';
 import { workbenchInstantiationService, registerTestEditor, TestFileEditorInput, TestEditorPart, TestServiceAccessor, createEditorPart, ITestInstantiationService, workbenchTeardown } from 'vs/workbench/test/browser/workbenchTestServices';
 import { GroupDirection, GroupsOrder, MergeGroupMode, GroupOrientation, GroupLocation, isEditorGroup, IEditorGroupsService, GroupsArrangement } from 'vs/workbench/services/editor/common/editorGroupsService';
-import { CloseDirection, IEditorPartOptions, EditorsOrder, EditorInputCapabilities, GroupModelChangeKind, SideBySideEditor } from 'vs/workbench/common/editor';
+import { CloseDirection, IEditorPartOptions, EditorsOrder, EditorInputCapabilities, GroupModelChangeKind, SideBySideEditor, IEditorFactoryRegistry, EditorExtensions } from 'vs/workbench/common/editor';
 import { URI } from 'vs/base/common/uri';
 import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 import { DisposableStore } from 'vs/base/common/lifecycle';
@@ -18,6 +18,7 @@ import { SideBySideEditorInput } from 'vs/workbench/common/editor/sideBySideEdit
 import { IGroupModelChangeEvent, IGroupEditorMoveEvent, IGroupEditorOpenEvent } from 'vs/workbench/common/editor/editorGroupModel';
 import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
 import { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils';
+import { Registry } from 'vs/platform/registry/common/platform';
 
 suite('EditorGroupsService', () => {
 
@@ -42,6 +43,7 @@ suite('EditorGroupsService', () => {
 	});
 
 	async function createPart(instantiationService = workbenchInstantiationService(undefined, disposables)): Promise<[TestEditorPart, TestInstantiationService]> {
+		instantiationService.invokeFunction(accessor => Registry.as<IEditorFactoryRegistry>(EditorExtensions.EditorFactory).start(accessor));
 		const part = await createEditorPart(instantiationService, disposables);
 		instantiationService.stub(IEditorGroupsService, part);
 
@@ -1915,12 +1917,10 @@ suite('EditorGroupsService', () => {
 	test('working sets - create / apply state', async function () {
 		const [part] = await createPart();
 
-		const group = part.activeGroup;
-
 		const input = createTestFileEditorInput(URI.file('foo/bar'), TEST_EDITOR_INPUT_ID);
 		const input2 = createTestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID);
 
-		const pane1 = await group.openEditor(input, { pinned: true });
+		const pane1 = await part.activeGroup.openEditor(input, { pinned: true });
 		const pane2 = await part.sideGroup.openEditor(input2, { pinned: true });
 
 		const state = part.createState();
@@ -1934,6 +1934,39 @@ suite('EditorGroupsService', () => {
 		await part.applyState(state);
 
 		assert.strictEqual(part.count, 2);
+
+		assert.strictEqual(part.groups[0].contains(input), true);
+		assert.strictEqual(part.groups[1].contains(input2), true);
+
+		for (const group of part.groups) {
+			await group.closeAllEditors();
+		}
+
+		const emptyState = part.createState();
+
+		await part.applyState(emptyState);
+		assert.strictEqual(part.count, 1);
+
+		const input3 = createTestFileEditorInput(URI.file('foo/bar3'), TEST_EDITOR_INPUT_ID);
+		input3.dirty = true;
+		await part.activeGroup.openEditor(input3, { pinned: true });
+
+		await part.applyState(emptyState);
+
+		assert.strictEqual(part.count, 1);
+		assert.strictEqual(part.groups[0].contains(input3), true); // dirty editors enforce to be there even when state is empty
+
+		await part.applyState('empty');
+
+		assert.strictEqual(part.count, 1);
+		assert.strictEqual(part.groups[0].contains(input3), true); // dirty editors enforce to be there even when state is empty
+
+		input3.dirty = false;
+
+		await part.applyState('empty');
+
+		assert.strictEqual(part.count, 1);
+		assert.strictEqual(part.activeGroup.isEmpty, true);
 	});
 
 	ensureNoDisposablesAreLeakedInTestSuite();

src/vs/workbench/test/browser/workbenchTestServices.ts

@@ -841,7 +841,7 @@ export class TestEditorGroupsService implements IEditorGroupsService {
 	getPart(group: number | IEditorGroup): IEditorPart { return this; }
 	saveWorkingSet(name: string): IEditorWorkingSet { throw new Error('Method not implemented.'); }
 	getWorkingSets(): IEditorWorkingSet[] { throw new Error('Method not implemented.'); }
-	applyWorkingSet(workingSet: IEditorWorkingSet): Promise<boolean> { throw new Error('Method not implemented.'); }
+	applyWorkingSet(workingSet: IEditorWorkingSet | 'empty'): Promise<boolean> { throw new Error('Method not implemented.'); }
 	deleteWorkingSet(workingSet: IEditorWorkingSet): Promise<boolean> { throw new Error('Method not implemented.'); }
 	getGroups(_order?: GroupsOrder): readonly IEditorGroup[] { return this.groups; }
 	getGroup(identifier: number): IEditorGroup | undefined { return this.groups.find(group => group.id === identifier); }
@@ -1837,7 +1837,7 @@ export class TestEditorPart extends MainEditorPart implements IEditorGroupsServi
 
 	saveWorkingSet(name: string): IEditorWorkingSet { throw new Error('Method not implemented.'); }
 	getWorkingSets(): IEditorWorkingSet[] { throw new Error('Method not implemented.'); }
-	applyWorkingSet(workingSet: IEditorWorkingSet): Promise<boolean> { throw new Error('Method not implemented.'); }
+	applyWorkingSet(workingSet: IEditorWorkingSet | 'empty'): Promise<boolean> { throw new Error('Method not implemented.'); }
 	deleteWorkingSet(workingSet: IEditorWorkingSet): Promise<boolean> { throw new Error('Method not implemented.'); }
 }