Merge from vscode 8e0f348413f4f616c23a88ae30030efa85811973 (#6381)

* Merge from vscode 8e0f348413f4f616c23a88ae30030efa85811973 * disable strict null check
2026-01-19 17:22:48 -05:00 · 2019-07-15 22:35:46 -07:00
parent f720ec642f
commit 0b7e7ddbf9
2406 changed files with 59140 additions and 35464 deletions
--- a/src/vs/workbench/api/browser/mainThreadComments.ts
+++ b/src/vs/workbench/api/browser/mainThreadComments.ts
@@ -3,85 +3,25 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { Disposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
-import { ICodeEditor, isCodeEditor, isDiffEditor, IDiffEditor } from 'vs/editor/browser/editorBrowser';
-import * as modes from 'vs/editor/common/modes';
-import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { Emitter, Event } from 'vs/base/common/event';
+import { Disposable, DisposableStore, dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { keys } from 'vs/base/common/map';
-import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
-import { ExtHostCommentsShape, ExtHostContext, IExtHostContext, MainContext, MainThreadCommentsShape, CommentProviderFeatures } from '../common/extHost.protocol';
-
-import { ICommentService, ICommentInfo } from 'vs/workbench/contrib/comments/browser/commentService';
-import { COMMENTS_PANEL_ID, CommentsPanel, COMMENTS_PANEL_TITLE } from 'vs/workbench/contrib/comments/browser/commentsPanel';
-import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { generateUuid } from 'vs/base/common/uuid';
-import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { ICommentsConfiguration } from 'vs/workbench/contrib/comments/browser/comments.contribution';
+import { IRange } from 'vs/editor/common/core/range';
+import * as modes from 'vs/editor/common/modes';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { Registry } from 'vs/platform/registry/common/platform';
-import { PanelRegistry, Extensions as PanelExtensions, PanelDescriptor } from 'vs/workbench/browser/panel';
-import { IRange, Range } from 'vs/editor/common/core/range';
-import { Emitter, Event } from 'vs/base/common/event';
-import { CancellationToken } from 'vs/base/common/cancellation';
-
-export class MainThreadDocumentCommentProvider implements modes.DocumentCommentProvider {
-	private readonly _proxy: ExtHostCommentsShape;
-	private readonly _handle: number;
-	private readonly _features: CommentProviderFeatures;
-	get startDraftLabel(): string | undefined { return this._features.startDraftLabel; }
-	get deleteDraftLabel(): string | undefined { return this._features.deleteDraftLabel; }
-	get finishDraftLabel(): string | undefined { return this._features.finishDraftLabel; }
-	get reactionGroup(): modes.CommentReaction[] | undefined { return this._features.reactionGroup; }
-
-	constructor(proxy: ExtHostCommentsShape, handle: number, features: CommentProviderFeatures) {
-		this._proxy = proxy;
-		this._handle = handle;
-		this._features = features;
-	}
-
-	async provideDocumentComments(uri: URI, token: CancellationToken) {
-		return this._proxy.$provideDocumentComments(this._handle, uri);
-	}
-
-	async createNewCommentThread(uri: URI, range: Range, text: string, token: CancellationToken) {
-		return this._proxy.$createNewCommentThread(this._handle, uri, range, text);
-	}
-
-	async replyToCommentThread(uri: URI, range: Range, thread: modes.CommentThread, text: string, token: CancellationToken) {
-		return this._proxy.$replyToCommentThread(this._handle, uri, range, thread, text);
-	}
-
-	async editComment(uri: URI, comment: modes.Comment, text: string, token: CancellationToken) {
-		return this._proxy.$editComment(this._handle, uri, comment, text);
-	}
-
-	async deleteComment(uri: URI, comment: modes.Comment, token: CancellationToken) {
-		return this._proxy.$deleteComment(this._handle, uri, comment);
-	}
-
-	async startDraft(uri: URI, token: CancellationToken): Promise<void> {
-		return this._proxy.$startDraft(this._handle, uri);
-	}
-	async deleteDraft(uri: URI, token: CancellationToken): Promise<void> {
-		return this._proxy.$deleteDraft(this._handle, uri);
-	}
-	async finishDraft(uri: URI, token: CancellationToken): Promise<void> {
-		return this._proxy.$finishDraft(this._handle, uri);
-	}
-	async addReaction(uri: URI, comment: modes.Comment, reaction: modes.CommentReaction, token: CancellationToken): Promise<void> {
-		return this._proxy.$addReaction(this._handle, uri, comment, reaction);
-	}
-	async deleteReaction(uri: URI, comment: modes.Comment, reaction: modes.CommentReaction, token: CancellationToken): Promise<void> {
-		return this._proxy.$deleteReaction(this._handle, uri, comment, reaction);
-	}
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { Extensions as PanelExtensions, PanelDescriptor, PanelRegistry } from 'vs/workbench/browser/panel';
+import { ICommentInfo, ICommentService } from 'vs/workbench/contrib/comments/browser/commentService';
+import { CommentsPanel, COMMENTS_PANEL_ID, COMMENTS_PANEL_TITLE } from 'vs/workbench/contrib/comments/browser/commentsPanel';
+import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
+import { CommentProviderFeatures, ExtHostCommentsShape, ExtHostContext, IExtHostContext, MainContext, MainThreadCommentsShape } from '../common/extHost.protocol';


-	// onDidChangeCommentThreads = null;
-}
-
-export class MainThreadCommentThread implements modes.CommentThread2 {
+export class MainThreadCommentThread implements modes.CommentThread {
 	private _input?: modes.CommentInput;
 	get input(): modes.CommentInput | undefined {
 		return this._input;
@@ -117,7 +57,7 @@ export class MainThreadCommentThread implements modes.CommentThread2 {
 	}

 	private _onDidChangeLabel = new Emitter<string>();
-	get onDidChangeLabel(): Event<string> { return this._onDidChangeLabel.event; }
+	readonly onDidChangeLabel: Event<string> = this._onDidChangeLabel.event;

 	private _comments: modes.Comment[] | undefined;

@@ -133,42 +73,6 @@ export class MainThreadCommentThread implements modes.CommentThread2 {
 	private _onDidChangeComments = new Emitter<modes.Comment[] | undefined>();
 	get onDidChangeComments(): Event<modes.Comment[] | undefined> { return this._onDidChangeComments.event; }

-	private _acceptInputCommand: modes.Command | undefined;
-	set acceptInputCommand(newCommand: modes.Command | undefined) {
-		this._acceptInputCommand = newCommand;
-		this._onDidChangeAcceptInputCommand.fire(this._acceptInputCommand);
-	}
-
-	get acceptInputCommand(): modes.Command | undefined {
-		return this._acceptInputCommand!;
-	}
-
-	private _onDidChangeAcceptInputCommand = new Emitter<modes.Command | undefined>();
-	get onDidChangeAcceptInputCommand(): Event<modes.Command | undefined> { return this._onDidChangeAcceptInputCommand.event; }
-
-	private _additionalCommands: modes.Command[] | undefined;
-	set additionalCommands(newCommands: modes.Command[] | undefined) {
-		this._additionalCommands = newCommands;
-		this._onDidChangeAdditionalCommands.fire(this._additionalCommands);
-	}
-
-	get additionalCommands(): modes.Command[] | undefined {
-		return this._additionalCommands;
-	}
-
-	private _onDidChangeAdditionalCommands = new Emitter<modes.Command[] | undefined>();
-	get onDidChangeAdditionalCommands(): Event<modes.Command[] | undefined> { return this._onDidChangeAdditionalCommands.event; }
-
-	private _deleteCommand: modes.Command | undefined;
-
-	set deleteCommand(newCommand: modes.Command | undefined) {
-		this._deleteCommand = newCommand;
-	}
-
-	get deleteCommand(): modes.Command | undefined {
-		return this._deleteCommand;
-	}
-
 	set range(range: IRange) {
 		this._range = range;
 		this._onDidChangeRange.fire(this._range);
@@ -216,24 +120,16 @@ export class MainThreadCommentThread implements modes.CommentThread2 {
 		label: string,
 		contextValue: string | undefined,
 		comments: modes.Comment[],
-		acceptInputCommand: modes.Command | undefined,
-		additionalCommands: modes.Command[],
-		deleteCommand: modes.Command | undefined,
 		collapsibleState: modes.CommentThreadCollapsibleState) {
 		this._range = range;
 		this._label = label;
 		this._contextValue = contextValue;
 		this._comments = comments;
-		this._acceptInputCommand = acceptInputCommand;
-		this._additionalCommands = additionalCommands;
-		this._deleteCommand = deleteCommand;
 		this._collapsibleState = collapsibleState;
 	}

 	dispose() {
 		this._isDisposed = true;
-		this._onDidChangeAcceptInputCommand.dispose();
-		this._onDidChangeAdditionalCommands.dispose();
 		this._onDidChangeCollasibleState.dispose();
 		this._onDidChangeComments.dispose();
 		this._onDidChangeInput.dispose();
@@ -284,6 +180,9 @@ export class MainThreadCommentController {
 	private readonly _threads: Map<number, MainThreadCommentThread> = new Map<number, MainThreadCommentThread>();
 	public activeCommentThread?: MainThreadCommentThread;

+	get features(): CommentProviderFeatures {
+		return this._features;
+	}

 	constructor(
 		private readonly _proxy: ExtHostCommentsShape,
@@ -299,15 +198,16 @@ export class MainThreadCommentController {
 		this._features = features;
 	}

-	createCommentThread(commentThreadHandle: number,
+	createCommentThread(extensionId: string,
+		commentThreadHandle: number,
 		threadId: string,
 		resource: UriComponents,
 		range: IRange,
-	): modes.CommentThread2 {
+	): modes.CommentThread {
 		let thread = new MainThreadCommentThread(
 			commentThreadHandle,
 			this.handle,
-			'',
+			extensionId,
 			threadId,
 			URI.revive(resource).toString(),
 			range
@@ -315,17 +215,11 @@ export class MainThreadCommentController {

 		this._threads.set(commentThreadHandle, thread);

-		// As we create comment thread from template and then restore from the newly created maint thread comment thread,
-		// we postpone the update event to avoid duplication.
-		// This can be actually removed once we are on the new API.
-		setTimeout(() => {
-			this._commentService.updateComments(this._uniqueId, {
-				added: [thread],
-				removed: [],
-				changed: [],
-				draftMode: modes.DraftMode.NotSupported
-			});
-		}, 0);
+		this._commentService.updateComments(this._uniqueId, {
+			added: [thread],
+			removed: [],
+			changed: []
+		});

 		return thread;
 	}
@@ -337,18 +231,14 @@ export class MainThreadCommentController {
 		label: string,
 		contextValue: string | undefined,
 		comments: modes.Comment[],
-		acceptInputCommand: modes.Command | undefined,
-		additionalCommands: modes.Command[],
-		deleteCommand: modes.Command | undefined,
 		collapsibleState: modes.CommentThreadCollapsibleState): void {
 		let thread = this.getKnownThread(commentThreadHandle);
-		thread.batchUpdate(range, label, contextValue, comments, acceptInputCommand, additionalCommands, deleteCommand, collapsibleState);
+		thread.batchUpdate(range, label, contextValue, comments, collapsibleState);

 		this._commentService.updateComments(this._uniqueId, {
 			added: [],
 			removed: [],
-			changed: [thread],
-			draftMode: modes.DraftMode.NotSupported
+			changed: [thread]
 		});
 	}

@@ -359,8 +249,7 @@ export class MainThreadCommentController {
 		this._commentService.updateComments(this._uniqueId, {
 			added: [],
 			removed: [thread],
-			changed: [],
-			draftMode: modes.DraftMode.NotSupported
+			changed: []
 		});

 		thread.dispose();
@@ -393,7 +282,7 @@ export class MainThreadCommentController {
 	}

 	async getDocumentComments(resource: URI, token: CancellationToken) {
-		let ret: modes.CommentThread2[] = [];
+		let ret: modes.CommentThread[] = [];
 		for (let thread of keys(this._threads)) {
 			const commentThread = this._threads.get(thread)!;
 			if (commentThread.resource === resource.toString()) {
@@ -402,26 +291,15 @@ export class MainThreadCommentController {
 		}

 		let commentingRanges = await this._proxy.$provideCommentingRanges(this.handle, resource, token);
-		let staticContribution = await this._proxy.$checkStaticContribution(this.handle);

 		return <ICommentInfo>{
 			owner: this._uniqueId,
 			label: this.label,
 			threads: ret,
-			commentingRanges: commentingRanges ? {
+			commentingRanges: {
 				resource: resource,
-				ranges: commentingRanges,
-				newCommentThreadCallback: staticContribution ? undefined : async (uri: UriComponents, range: IRange) => {
-					let threadHandle = await this._proxy.$createNewCommentWidgetCallback(this.handle, uri, range, token);
-
-					// if (threadHandle !== undefined) { {{SQL CARBON EDIT}} @anthonydresser this never happens but throws error because of strict null checks
-					// return this.getKnownThread(threadHandle);
-					// }
-
-					return undefined; // {{SQL CARBON EDIT}} @anthonydresser revert back after strict-null-check
-				}
-			} : [],
-			draftMode: modes.DraftMode.NotSupported
+				ranges: commentingRanges || []
+			}
 		};
 	}

@@ -434,7 +312,7 @@ export class MainThreadCommentController {
 		return this._features.reactionGroup;
 	}

-	async toggleReaction(uri: URI, thread: modes.CommentThread2, comment: modes.Comment, reaction: modes.CommentReaction, token: CancellationToken): Promise<void> {
+	async toggleReaction(uri: URI, thread: modes.CommentThread, comment: modes.Comment, reaction: modes.CommentReaction, token: CancellationToken): Promise<void> {
 		return this._proxy.$toggleReaction(this._handle, thread.commentThreadHandle, uri, comment, reaction);
 	}

@@ -451,6 +329,10 @@ export class MainThreadCommentController {
 		this._proxy.$createCommentThreadTemplate(this.handle, resource, range);
 	}

+	async updateCommentThreadTemplate(threadHandle: number, range: IRange) {
+		await this._proxy.$updateCommentThreadTemplate(this.handle, threadHandle, range);
+	}
+
 	toJSON(): any {
 		return {
 			$mid: 6,
@@ -461,28 +343,38 @@ export class MainThreadCommentController {

@extHostNamedCustomer(MainContext.MainThreadComments)
 export class MainThreadComments extends Disposable implements MainThreadCommentsShape {
-	private _disposables: IDisposable[];
-	private _activeCommentThreadDisposables: IDisposable[];
 	private readonly _proxy: ExtHostCommentsShape;
 	private _documentProviders = new Map<number, IDisposable>();
 	private _workspaceProviders = new Map<number, IDisposable>();
 	private _handlers = new Map<number, string>();
 	private _commentControllers = new Map<number, MainThreadCommentController>();

+	private _activeCommentThread?: MainThreadCommentThread;
+	private readonly _activeCommentThreadDisposables = this._register(new DisposableStore());
+
 	private _openPanelListener: IDisposable | null;

+
 	constructor(
 		extHostContext: IExtHostContext,
-		@IEditorService private readonly _editorService: IEditorService,
 		@ICommentService private readonly _commentService: ICommentService,
-		@IPanelService private readonly _panelService: IPanelService,
-		@ITelemetryService private readonly _telemetryService: ITelemetryService,
-		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@IPanelService private readonly _panelService: IPanelService
 	) {
 		super();
-		this._disposables = [];
-		this._activeCommentThreadDisposables = [];
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostComments);
+
+		this._register(this._commentService.onDidChangeActiveCommentThread(async thread => {
+			let handle = (thread as MainThreadCommentThread).controllerHandle;
+			let controller = this._commentControllers.get(handle);
+
+			if (!controller) {
+				return;
+			}
+
+			this._activeCommentThreadDisposables.clear();
+			this._activeCommentThread = thread as MainThreadCommentThread;
+			controller.activeCommentThread = this._activeCommentThread;
+		}));
 	}

 	$registerCommentController(handle: number, id: string, label: string): void {
@@ -525,15 +417,16 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		commentThreadHandle: number,
 		threadId: string,
 		resource: UriComponents,
-		range: IRange
-	): modes.CommentThread2 | undefined {
+		range: IRange,
+		extensionId: ExtensionIdentifier
+	): modes.CommentThread | undefined {
 		let provider = this._commentControllers.get(handle);

 		if (!provider) {
 			return undefined;
 		}

-		return provider.createCommentThread(commentThreadHandle, threadId, resource, range);
+		return provider.createCommentThread(extensionId.value, commentThreadHandle, threadId, resource, range);
 	}

 	$updateCommentThread(handle: number,
@@ -544,9 +437,6 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		label: string,
 		contextValue: string | undefined,
 		comments: modes.Comment[],
-		acceptInputCommand: modes.Command | undefined,
-		additionalCommands: modes.Command[],
-		deleteCommand: modes.Command,
 		collapsibleState: modes.CommentThreadCollapsibleState): void {
 		let provider = this._commentControllers.get(handle);

@@ -554,7 +444,7 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 			return undefined;
 		}

-		return provider.updateCommentThread(commentThreadHandle, threadId, resource, range, label, contextValue, comments, acceptInputCommand, additionalCommands, deleteCommand, collapsibleState);
+		return provider.updateCommentThread(commentThreadHandle, threadId, resource, range, label, contextValue, comments, collapsibleState);
 	}

 	$deleteCommentThread(handle: number, commentThreadHandle: number) {
@@ -567,26 +457,6 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		return provider.deleteCommentThread(commentThreadHandle);
 	}

-	$setInputValue(handle: number, input: string) {
-		let provider = this._commentControllers.get(handle);
-
-		if (!provider) {
-			return;
-		}
-
-		provider.updateInput(input);
-	}
-
-	$registerDocumentCommentProvider(handle: number, features: CommentProviderFeatures): void {
-		this._documentProviders.set(handle, undefined);
-		const handler = new MainThreadDocumentCommentProvider(this._proxy, handle, features);
-
-		const providerId = generateUuid();
-		this._handlers.set(handle, providerId);
-
-		this._commentService.registerDataProvider(providerId, handler);
-	}
-
 	private registerPanel(commentsPanelAlreadyConstructed: boolean) {
 		if (!commentsPanelAlreadyConstructed) {
 			Registry.as<PanelRegistry>(PanelExtensions.Panels).registerPanel(new PanelDescriptor(
@@ -608,15 +478,6 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		if (!commentsPanelAlreadyConstructed && !this._openPanelListener) {
 			this._openPanelListener = this._panelService.onDidPanelOpen(e => {
 				if (e.panel.getId() === COMMENTS_PANEL_ID) {
-					keys(this._workspaceProviders).forEach(handle => {
-						this._proxy.$provideWorkspaceComments(handle).then(commentThreads => {
-							if (commentThreads) {
-								const providerId = this.getHandler(handle);
-								this._commentService.setWorkspaceComments(providerId, commentThreads);
-							}
-						});
-					});
-
 					keys(this._commentControllers).forEach(handle => {
 						let threads = this._commentControllers.get(handle)!.getAllComments();

@@ -642,119 +503,14 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		return this._handlers.get(handle)!;
 	}

-	$registerWorkspaceCommentProvider(handle: number, extensionId: ExtensionIdentifier): void {
-		this._workspaceProviders.set(handle, undefined);
-
-		const providerId = generateUuid();
-		this._handlers.set(handle, providerId);
-
-		const commentsPanelAlreadyConstructed = this._panelService.getPanels().some(panel => panel.id === COMMENTS_PANEL_ID);
-		if (!commentsPanelAlreadyConstructed) {
-			this.registerPanel(commentsPanelAlreadyConstructed);
-		}
-
-		const openPanel = this._configurationService.getValue<ICommentsConfiguration>('comments').openPanel;
-
-		if (openPanel === 'neverOpen') {
-			this.registerOpenPanelListener(commentsPanelAlreadyConstructed);
-		}
-
-		if (openPanel === 'openOnSessionStart') {
-			this._panelService.openPanel(COMMENTS_PANEL_ID);
-		}
-
-		this._proxy.$provideWorkspaceComments(handle).then(commentThreads => {
-			if (commentThreads) {
-				if (openPanel === 'openOnSessionStartWithComments' && commentThreads.length) {
-					if (commentThreads.length) {
-						this._panelService.openPanel(COMMENTS_PANEL_ID);
-					} else {
-						this.registerOpenPanelListener(commentsPanelAlreadyConstructed);
-					}
-				}
-
-				this._commentService.setWorkspaceComments(providerId, commentThreads);
-			}
-		});
-
-		/* __GDPR__
-			"comments:registerWorkspaceCommentProvider" : {
-				"extensionId" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-			}
-		*/
-		this._telemetryService.publicLog('comments:registerWorkspaceCommentProvider', {
-			extensionId: extensionId.value
-		});
-	}
-
-	$unregisterDocumentCommentProvider(handle: number): void {
-		this._documentProviders.delete(handle);
-		const handlerId = this.getHandler(handle);
-		this._commentService.unregisterDataProvider(handlerId);
-		this._handlers.delete(handle);
-	}
-
-	$unregisterWorkspaceCommentProvider(handle: number): void {
-		this._workspaceProviders.delete(handle);
-		if (this._workspaceProviders.size === 0) {
-			Registry.as<PanelRegistry>(PanelExtensions.Panels).deregisterPanel(COMMENTS_PANEL_ID);
-
-			if (this._openPanelListener) {
-				this._openPanelListener.dispose();
-				this._openPanelListener = null;
-			}
-		}
-
-		const handlerId = this.getHandler(handle);
-		this._commentService.removeWorkspaceComments(handlerId);
-		this._handlers.delete(handle);
-	}
-
 	$onDidCommentThreadsChange(handle: number, event: modes.CommentThreadChangedEvent) {
 		// notify comment service
 		const providerId = this.getHandler(handle);
 		this._commentService.updateComments(providerId, event);
 	}

-	getVisibleEditors(): ICodeEditor[] {
-		let ret: ICodeEditor[] = [];
-
-		this._editorService.visibleControls.forEach(control => {
-			if (isCodeEditor(control.getControl())) {
-				ret.push(control.getControl() as ICodeEditor);
-			}
-
-			if (isDiffEditor(control.getControl())) {
-				let diffEditor = control.getControl() as IDiffEditor;
-				ret.push(diffEditor.getOriginalEditor(), diffEditor.getModifiedEditor());
-			}
-		});
-
-		return ret;
-	}
-
-	async provideWorkspaceComments(): Promise<modes.CommentThread[]> {
-		const result: modes.CommentThread[] = [];
-		for (const handle of keys(this._workspaceProviders)) {
-			const result = await this._proxy.$provideWorkspaceComments(handle);
-			if (Array.isArray(result)) {
-				result.push(...result);
-			}
-		}
-		return result;
-	}
-
-	async provideDocumentComments(resource: URI): Promise<Array<modes.CommentInfo | null>> {
-		const result: Array<modes.CommentInfo | null> = [];
-		for (const handle of keys(this._documentProviders)) {
-			result.push(await this._proxy.$provideDocumentComments(handle, resource));
-		}
-		return result;
-	}
-
 	dispose(): void {
-		this._disposables = dispose(this._disposables);
-		this._activeCommentThreadDisposables = dispose(this._activeCommentThreadDisposables);
+		super.dispose();
 		this._workspaceProviders.forEach(value => dispose(value));
 		this._workspaceProviders.clear();
 		this._documentProviders.forEach(value => dispose(value));