Merge from vscode 33a65245075e4d18908652865a79cf5489c30f40 (#9279)

* Merge from vscode 33a65245075e4d18908652865a79cf5489c30f40 * remove github
2026-02-04 01:25:38 -05:00 · 2020-02-21 23:42:19 -08:00
parent c446cea3a0
commit de5f1eb780
250 changed files with 3724 additions and 2756 deletions
--- a/src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts
+++ b/src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts
@@ -19,7 +19,7 @@ import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { URI } from 'vs/base/common/uri';
 import { Selection } from 'vs/editor/common/core/selection';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
-import * as callh from 'vs/workbench/contrib/callHierarchy/browser/callHierarchy';
+import * as callh from 'vs/workbench/contrib/callHierarchy/common/callHierarchy';
 import { mixin } from 'vs/base/common/objects';
 import { decodeSemanticTokensDto } from 'vs/workbench/api/common/shared/semanticTokens';

@@ -273,7 +273,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha

 	// --- quick fix

-	$registerQuickFixSupport(handle: number, selector: IDocumentFilterDto[], metadata: ICodeActionProviderMetadataDto): void {
+	$registerQuickFixSupport(handle: number, selector: IDocumentFilterDto[], metadata: ICodeActionProviderMetadataDto, displayName: string): void {
 		this._registrations.set(handle, modes.CodeActionProviderRegistry.register(selector, <modes.CodeActionProvider>{
 			provideCodeActions: async (model: ITextModel, rangeOrSelection: EditorRange | Selection, context: modes.CodeActionContext, token: CancellationToken): Promise<modes.CodeActionList | undefined> => {
 				const listDto = await this._proxy.$provideCodeActions(handle, model.uri, rangeOrSelection, context, token);
@@ -290,7 +290,8 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 				};
 			},
 			providedCodeActionKinds: metadata.providedKinds,
-			documentation: metadata.documentation
+			documentation: metadata.documentation,
+			displayName
 		}));
 	}

--- a/src/vs/workbench/api/browser/mainThreadTask.ts
+++ b/src/vs/workbench/api/browser/mainThreadTask.ts
@@ -512,7 +512,7 @@ export class MainThreadTask implements MainThreadTaskShape {
 	public $executeTask(value: TaskHandleDTO | TaskDTO): Promise<TaskExecutionDTO> {
 		return new Promise<TaskExecutionDTO>((resolve, reject) => {
 			if (TaskHandleDTO.is(value)) {
-				const workspaceFolder = this._workspaceContextServer.getWorkspaceFolder(URI.revive(value.workspaceFolder));
+				const workspaceFolder = typeof value.workspaceFolder === 'string' ? value.workspaceFolder : this._workspaceContextServer.getWorkspaceFolder(URI.revive(value.workspaceFolder));
 				if (workspaceFolder) {
 					this._taskService.getTask(workspaceFolder, value.id, true).then((task: Task | undefined) => {
 						if (!task) {
--- a/src/vs/workbench/api/browser/mainThreadWebview.ts
+++ b/src/vs/workbench/api/browser/mainThreadWebview.ts
@@ -21,7 +21,7 @@ import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
 import { editorGroupToViewColumn, EditorViewColumn, viewColumnToEditorGroup } from 'vs/workbench/api/common/shared/editor';
 import { IEditorInput } from 'vs/workbench/common/editor';
 import { DiffEditorInput } from 'vs/workbench/common/editor/diffEditorInput';
-import { CustomFileEditorInput } from 'vs/workbench/contrib/customEditor/browser/customEditorInput';
+import { CustomEditorInput, ModelType } from 'vs/workbench/contrib/customEditor/browser/customEditorInput';
 import { ICustomEditorModel, ICustomEditorService } from 'vs/workbench/contrib/customEditor/common/customEditor';
 import { WebviewExtensionDescription } from 'vs/workbench/contrib/webview/browser/webview';
 import { WebviewInput } from 'vs/workbench/contrib/webview/browser/webviewEditorInput';
@@ -97,7 +97,7 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 	private readonly _webviewInputs = new WebviewInputStore();
 	private readonly _revivers = new Map<string, IDisposable>();
 	private readonly _editorProviders = new Map<string, IDisposable>();
-	private readonly _customEditorModels = new Map<ICustomEditorModel, { referenceCount: number }>();
+	private readonly _customEditorModels = new Map<string, { referenceCount: number }>();

 	constructor(
 		context: extHostProtocol.IExtHostContext,
@@ -121,7 +121,7 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 		// This should trigger the real reviver to be registered from the extension host side.
 		this._register(_webviewWorkbenchService.registerResolver({
 			canResolve: (webview: WebviewInput) => {
-				if (webview instanceof CustomFileEditorInput) {
+				if (webview instanceof CustomEditorInput) {
 					extensionService.activateByEvent(`onWebviewEditor:${webview.viewType}`);
 					return false;
 				}
@@ -256,7 +256,20 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 		this._revivers.delete(viewType);
 	}

-	public $registerEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: modes.IWebviewPanelOptions, capabilities: readonly extHostProtocol.WebviewEditorCapabilities[]): void {
+	public $registerTextEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: modes.IWebviewPanelOptions): void {
+		return this.registerEditorProvider(ModelType.Text, extensionData, viewType, options);
+	}
+
+	public $registerCustomEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: modes.IWebviewPanelOptions): void {
+		return this.registerEditorProvider(ModelType.Custom, extensionData, viewType, options);
+	}
+
+	public registerEditorProvider(
+		modelType: ModelType,
+		extensionData: extHostProtocol.WebviewExtensionDescription,
+		viewType: string,
+		options: modes.IWebviewPanelOptions,
+	): void {
 		if (this._editorProviders.has(viewType)) {
 			throw new Error(`Provider for ${viewType} already registered`);
 		}
@@ -265,21 +278,25 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma

 		this._editorProviders.set(viewType, this._webviewWorkbenchService.registerResolver({
 			canResolve: (webviewInput) => {
-				return webviewInput instanceof CustomFileEditorInput && webviewInput.viewType === viewType;
+				return webviewInput instanceof CustomEditorInput && webviewInput.viewType === viewType;
 			},
-			resolveWebview: async (webviewInput: CustomFileEditorInput) => {
+			resolveWebview: async (webviewInput: CustomEditorInput) => {
 				const handle = webviewInput.id;
 				this._webviewInputs.add(handle, webviewInput);
 				this.hookupWebviewEventDelegate(handle, webviewInput);

 				webviewInput.webview.options = options;
 				webviewInput.webview.extension = extension;
+				webviewInput.modelType = modelType;
+
 				const resource = webviewInput.resource;

-				const model = await this.retainCustomEditorModel(webviewInput, resource, viewType, capabilities);
-				webviewInput.onDisposeWebview(() => {
-					this.releaseCustomEditorModel(model);
-				});
+				if (modelType === ModelType.Custom) {
+					const model = await this.retainCustomEditorModel(webviewInput, resource, viewType);
+					webviewInput.onDisposeWebview(() => {
+						this.releaseCustomEditorModel(model);
+					});
+				}

 				try {
 					await this._proxy.$resolveWebviewEditor(
@@ -311,33 +328,26 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 		this._customEditorService.models.disposeAllModelsForView(viewType);
 	}

-	private async retainCustomEditorModel(webviewInput: WebviewInput, resource: URI, viewType: string, capabilities: readonly extHostProtocol.WebviewEditorCapabilities[]) {
+	private async retainCustomEditorModel(webviewInput: WebviewInput, resource: URI, viewType: string) {
 		const model = await this._customEditorService.models.resolve(webviewInput.resource, webviewInput.viewType);

-		const existingEntry = this._customEditorModels.get(model);
+		const key = viewType + resource.toString();
+		const existingEntry = this._customEditorModels.get(key);
 		if (existingEntry) {
 			++existingEntry.referenceCount;
 			// no need to hook up listeners again
 			return model;
 		}
+		this._customEditorModels.set(key, { referenceCount: 1 });
+		const { editable } = await this._proxy.$createWebviewCustomEditorDocument(resource, viewType);

-		this._customEditorModels.set(model, { referenceCount: 1 });
-
-		const capabilitiesSet = new Set(capabilities);
-		const isEditable = capabilitiesSet.has(extHostProtocol.WebviewEditorCapabilities.Editable);
-		if (isEditable) {
-			model.onUndo(e => {
-				this._proxy.$undoEdits(resource, viewType, e.edits);
+		if (editable) {
+			model.onUndo(() => {
+				this._proxy.$undo(resource, viewType);
 			});

-			model.onDisposeEdits(e => {
-				this._proxy.$disposeEdits(e.edits);
-			});
-
-			model.onApplyEdit(e => {
-				if (e.trigger !== model) {
-					this._proxy.$applyEdits(resource, viewType, e.edits);
-				}
+			model.onRedo(() => {
+				this._proxy.$redo(resource, viewType);
 			});

 			model.onWillSave(e => {
@@ -347,7 +357,7 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma

 		// Save as should always be implemented even if the model is readonly
 		model.onWillSaveAs(e => {
-			if (isEditable) {
+			if (editable) {
 				e.waitUntil(this._proxy.$onSaveAs(e.resource.toJSON(), viewType, e.targetResource.toJSON()));
 			} else {
 				// Since the editor is readonly, just copy the file over
@@ -355,36 +365,37 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 			}
 		});

-		if (capabilitiesSet.has(extHostProtocol.WebviewEditorCapabilities.SupportsHotExit)) {
-			model.onBackup(() => {
-				return createCancelablePromise(token =>
-					this._proxy.$backup(model.resource.toJSON(), viewType, token));
-			});
-		}
+		model.onBackup(() => {
+			return createCancelablePromise(token =>
+				this._proxy.$backup(model.resource.toJSON(), viewType, token));
+		});

 		return model;
 	}

 	private async releaseCustomEditorModel(model: ICustomEditorModel) {
-		const entry = this._customEditorModels.get(model);
+		const key = model.viewType + model.resource;
+		const entry = this._customEditorModels.get(key);
 		if (!entry) {
-			return;
+			throw new Error('Model not found');
 		}

 		--entry.referenceCount;
 		if (entry.referenceCount <= 0) {
+			this._proxy.$disposeWebviewCustomEditorDocument(model.resource, model.viewType);
 			this._customEditorService.models.disposeModel(model);
-			this._customEditorModels.delete(model);
+			this._customEditorModels.delete(key);
 		}
 	}

-	public $onEdit(resource: UriComponents, viewType: string, editId: number): void {
+
+
+	public $onDidChangeCustomDocumentState(resource: UriComponents, viewType: string, state: { dirty: boolean }) {
 		const model = this._customEditorService.models.get(URI.revive(resource), viewType);
 		if (!model) {
 			throw new Error('Could not find model for webview editor');
 		}
-
-		model.pushEdit(editId, model);
+		model.setDirty(state.dirty);
 	}

 	private hookupWebviewEventDelegate(handle: extHostProtocol.WebviewPanelHandle, input: WebviewInput) {
--- a/src/vs/workbench/api/common/extHost.api.impl.ts
+++ b/src/vs/workbench/api/common/extHost.api.impl.ts
@@ -114,7 +114,6 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostOutputService = rpcProtocol.set(ExtHostContext.ExtHostOutputService, accessor.get(IExtHostOutputService));

 	// manually create and register addressable instances
-	const extHostWebviews = rpcProtocol.set(ExtHostContext.ExtHostWebviews, new ExtHostWebviews(rpcProtocol, initData.environment, extHostWorkspace, extHostLogService));
 	const extHostUrls = rpcProtocol.set(ExtHostContext.ExtHostUrls, new ExtHostUrls(rpcProtocol));
 	const extHostDocuments = rpcProtocol.set(ExtHostContext.ExtHostDocuments, new ExtHostDocuments(rpcProtocol, extHostDocumentsAndEditors));
 	const extHostDocumentContentProviders = rpcProtocol.set(ExtHostContext.ExtHostDocumentContentProviders, new ExtHostDocumentContentProvider(rpcProtocol, extHostDocumentsAndEditors, extHostLogService));
@@ -135,6 +134,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostTheming = rpcProtocol.set(ExtHostContext.ExtHostTheming, new ExtHostTheming(rpcProtocol));
 	const extHostAuthentication = rpcProtocol.set(ExtHostContext.ExtHostAuthentication, new ExtHostAuthentication(rpcProtocol));
 	const extHostTimeline = rpcProtocol.set(ExtHostContext.ExtHostTimeline, new ExtHostTimeline(rpcProtocol, extHostCommands));
+	const extHostWebviews = rpcProtocol.set(ExtHostContext.ExtHostWebviews, new ExtHostWebviews(rpcProtocol, initData.environment, extHostWorkspace, extHostLogService, extHostApiDeprecation, extHostDocuments));

 	// Check that no named customers are missing
 	// {{SQL CARBON EDIT}} filter out the services we don't expose
@@ -564,10 +564,18 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			registerWebviewPanelSerializer: (viewType: string, serializer: vscode.WebviewPanelSerializer) => {
 				return extHostWebviews.registerWebviewPanelSerializer(extension, viewType, serializer);
 			},
+			registerWebviewTextEditorProvider: (viewType: string, provider: vscode.WebviewTextEditorProvider, options?: vscode.WebviewPanelOptions) => {
+				checkProposedApiEnabled(extension);
+				return extHostWebviews.registerWebviewTextEditorProvider(extension, viewType, provider, options);
+			},
 			registerWebviewCustomEditorProvider: (viewType: string, provider: vscode.WebviewCustomEditorProvider, options?: vscode.WebviewPanelOptions) => {
 				checkProposedApiEnabled(extension);
 				return extHostWebviews.registerWebviewCustomEditorProvider(extension, viewType, provider, options);
 			},
+			createWebviewEditorCustomDocument: <UserDataType>(viewType: string, resource: vscode.Uri, userData: UserDataType, capabilities: vscode.WebviewCustomEditorCapabilities) => {
+				checkProposedApiEnabled(extension);
+				return extHostWebviews.createWebviewEditorCustomDocument<UserDataType>(viewType, resource, userData, capabilities);
+			},
 			registerDecorationProvider(provider: vscode.DecorationProvider) {
 				checkProposedApiEnabled(extension);
 				return extHostDecorations.registerDecorationProvider(provider, extension.identifier);
--- a/src/vs/workbench/api/common/extHost.protocol.ts
+++ b/src/vs/workbench/api/common/extHost.protocol.ts
@@ -51,6 +51,8 @@ import { TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
 import { TunnelOptions } from 'vs/platform/remote/common/tunnel';
 import { Timeline, TimelineChangeEvent, TimelineCursor, TimelineProviderDescriptor } from 'vs/workbench/contrib/timeline/common/timeline';
 import { revive } from 'vs/base/common/marshalling';
+import { CallHierarchyItem } from 'vs/workbench/contrib/callHierarchy/common/callHierarchy';
+import { Dto } from 'vs/base/common/types';

 // {{SQL CARBON EDIT}}
 import { ITreeItem as sqlITreeItem } from 'sql/workbench/common/views';
@@ -363,7 +365,7 @@ export interface MainThreadLanguageFeaturesShape extends IDisposable {
 	$registerEvaluatableExpressionProvider(handle: number, selector: IDocumentFilterDto[]): void;
 	$registerDocumentHighlightProvider(handle: number, selector: IDocumentFilterDto[]): void;
 	$registerReferenceSupport(handle: number, selector: IDocumentFilterDto[]): void;
-	$registerQuickFixSupport(handle: number, selector: IDocumentFilterDto[], metadata: ICodeActionProviderMetadataDto): void;
+	$registerQuickFixSupport(handle: number, selector: IDocumentFilterDto[], metadata: ICodeActionProviderMetadataDto, displayName: string): void;
 	$registerDocumentFormattingSupport(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, displayName: string): void;
 	$registerRangeFormattingSupport(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, displayName: string): void;
 	$registerOnTypeFormattingSupport(handle: number, selector: IDocumentFilterDto[], autoFormatTriggerCharacters: string[], extensionId: ExtensionIdentifier): void;
@@ -574,11 +576,6 @@ export interface WebviewExtensionDescription {
 	readonly location: UriComponents;
 }

-export enum WebviewEditorCapabilities {
-	Editable,
-	SupportsHotExit,
-}
-
 export interface MainThreadWebviewsShape extends IDisposable {
 	$createWebviewPanel(extension: WebviewExtensionDescription, handle: WebviewPanelHandle, viewType: string, title: string, showOptions: WebviewPanelShowOptions, options: modes.IWebviewPanelOptions & modes.IWebviewOptions): void;
 	$disposeWebview(handle: WebviewPanelHandle): void;
@@ -594,10 +591,11 @@ export interface MainThreadWebviewsShape extends IDisposable {
 	$registerSerializer(viewType: string): void;
 	$unregisterSerializer(viewType: string): void;

-	$registerEditorProvider(extension: WebviewExtensionDescription, viewType: string, options: modes.IWebviewPanelOptions, capabilities: readonly WebviewEditorCapabilities[]): void;
+	$registerTextEditorProvider(extension: WebviewExtensionDescription, viewType: string, options: modes.IWebviewPanelOptions): void;
+	$registerCustomEditorProvider(extension: WebviewExtensionDescription, viewType: string, options: modes.IWebviewPanelOptions): void;
 	$unregisterEditorProvider(viewType: string): void;

-	$onEdit(resource: UriComponents, viewType: string, editId: number): void;
+	$onDidChangeCustomDocumentState(resource: UriComponents, viewType: string, state: { dirty: boolean }): void;
 }

 export interface WebviewPanelViewStateData {
@@ -615,12 +613,14 @@ export interface ExtHostWebviewsShape {
 	$onDidDisposeWebviewPanel(handle: WebviewPanelHandle): Promise<void>;

 	$deserializeWebviewPanel(newWebviewHandle: WebviewPanelHandle, viewType: string, title: string, state: any, position: EditorViewColumn, options: modes.IWebviewOptions & modes.IWebviewPanelOptions): Promise<void>;
+
 	$resolveWebviewEditor(resource: UriComponents, newWebviewHandle: WebviewPanelHandle, viewType: string, title: string, position: EditorViewColumn, options: modes.IWebviewOptions & modes.IWebviewPanelOptions): Promise<void>;
+	$createWebviewCustomEditorDocument(resource: UriComponents, viewType: string): Promise<{ editable: boolean }>;
+	$disposeWebviewCustomEditorDocument(resource: UriComponents, viewType: string): Promise<void>;

-	$undoEdits(resource: UriComponents, viewType: string, editIds: readonly number[]): void;
-	$applyEdits(resource: UriComponents, viewType: string, editIds: readonly number[]): void;
-	$disposeEdits(editIds: readonly number[]): void;
-
+	$undo(resource: UriComponents, viewType: string): void;
+	$redo(resource: UriComponents, viewType: string): void;
+	$revert(resource: UriComponents, viewType: string): void;
 	$onSave(resource: UriComponents, viewType: string): Promise<void>;
 	$onSaveAs(resource: UriComponents, viewType: string, targetResource: UriComponents): Promise<void>;

@@ -1194,16 +1194,7 @@ export interface ICodeLensDto {
 	command?: ICommandDto;
 }

-export interface ICallHierarchyItemDto {
-	_sessionId: string;
-	_itemId: string;
-	kind: modes.SymbolKind;
-	name: string;
-	detail?: string;
-	uri: UriComponents;
-	range: IRange;
-	selectionRange: IRange;
-}
+export type ICallHierarchyItemDto = Dto<CallHierarchyItem>;

 export interface IIncomingCallDto {
 	from: ICallHierarchyItemDto;
--- a/src/vs/workbench/api/common/extHostLanguageFeatures.ts
+++ b/src/vs/workbench/api/common/extHostLanguageFeatures.ts
@@ -1617,7 +1617,7 @@ export class ExtHostLanguageFeatures implements extHostProtocol.ExtHostLanguageF
 				kind: x.kind.value,
 				command: this._commands.converter.toInternal(x.command, store),
 			}))
-		});
+		}, ExtHostLanguageFeatures._extLabel(extension));
 		store.add(this._createDisposable(handle));
 		return store;
 	}
--- a/src/vs/workbench/api/common/extHostTask.ts
+++ b/src/vs/workbench/api/common/extHostTask.ts
@@ -26,6 +26,7 @@ import { Schemas } from 'vs/base/common/network';
 import * as Platform from 'vs/base/common/platform';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IExtHostApiDeprecationService } from 'vs/workbench/api/common/extHostApiDeprecationService';
+import { USER_TASKS_GROUP_KEY } from 'vs/workbench/contrib/tasks/common/taskService';

 export interface IExtHostTask extends ExtHostTaskShape {

@@ -192,9 +193,11 @@ export namespace CustomExecutionDTO {

 export namespace TaskHandleDTO {
 	export function from(value: types.Task): tasks.TaskHandleDTO {
-		let folder: UriComponents | undefined;
+		let folder: UriComponents | string;
 		if (value.scope !== undefined && typeof value.scope !== 'number') {
 			folder = value.scope.uri;
+		} else if (value.scope !== undefined && typeof value.scope === 'number') {
+			folder = USER_TASKS_GROUP_KEY;
 		}
 		return {
 			id: value._id!,
--- a/src/vs/workbench/api/common/extHostWebview.ts
+++ b/src/vs/workbench/api/common/extHostWebview.ts
@@ -3,6 +3,7 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

+import { CancellationToken } from 'vs/base/common/cancellation';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
@@ -10,15 +11,15 @@ import { generateUuid } from 'vs/base/common/uuid';
 import * as modes from 'vs/editor/common/modes';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { ILogService } from 'vs/platform/log/common/log';
+import { IExtHostApiDeprecationService } from 'vs/workbench/api/common/extHostApiDeprecationService';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
 import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
 import { IExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
 import { EditorViewColumn } from 'vs/workbench/api/common/shared/editor';
 import { asWebviewUri, WebviewInitData } from 'vs/workbench/api/common/shared/webview';
 import type * as vscode from 'vscode';
-import { Cache } from './cache';
-import { ExtHostWebviewsShape, IMainContext, MainContext, MainThreadWebviewsShape, WebviewEditorCapabilities, WebviewPanelHandle, WebviewPanelViewStateData } from './extHost.protocol';
+import { ExtHostWebviewsShape, IMainContext, MainContext, MainThreadWebviewsShape, WebviewExtensionDescription, WebviewPanelHandle, WebviewPanelViewStateData } from './extHost.protocol';
 import { Disposable as VSCodeDisposable } from './extHostTypes';
-import { CancellationToken } from 'vs/base/common/cancellation';

 type IconPath = URI | { light: URI, dark: URI };

@@ -37,7 +38,7 @@ export class ExtHostWebview implements vscode.Webview {
 		private readonly _initData: WebviewInitData,
 		private readonly _workspace: IExtHostWorkspace | undefined,
 		private readonly _extension: IExtensionDescription,
-		private readonly _logService: ILogService,
+		private readonly _deprecationService: IExtHostApiDeprecationService,
 	) { }

 	public dispose() {
@@ -63,11 +64,10 @@ export class ExtHostWebview implements vscode.Webview {
 		this.assertNotDisposed();
 		if (this._html !== value) {
 			this._html = value;
-			if (this._initData.isExtensionDevelopmentDebug && !this._hasCalledAsWebviewUri) {
-				if (/(["'])vscode-resource:([^\s'"]+?)(["'])/i.test(value)) {
-					this._hasCalledAsWebviewUri = true;
-					this._logService.warn(`${this._extension.identifier.value} created a webview that appears to use the vscode-resource scheme directly. Please migrate to use the 'webview.asWebviewUri' api instead: https://aka.ms/vscode-webview-use-aswebviewuri`);
-				}
+			if (!this._hasCalledAsWebviewUri && /(["'])vscode-resource:([^\s'"]+?)(["'])/i.test(value)) {
+				this._hasCalledAsWebviewUri = true;
+				this._deprecationService.report('Webview vscode-resource: uris', this._extension,
+					`Please migrate to use the 'webview.asWebviewUri' api instead: https://aka.ms/vscode-webview-use-aswebviewuri`);
 			}
 			this._proxy.$setHtml(this._handle, value);
 		}
@@ -245,6 +245,193 @@ export class ExtHostWebviewEditor extends Disposable implements vscode.WebviewPa
 	}
 }

+type EditType = unknown;
+
+class WebviewEditorCustomDocument extends Disposable implements vscode.WebviewEditorCustomDocument {
+	private _currentEditIndex: number = -1;
+	private _savePoint: number = -1;
+	private readonly _edits: Array<EditType> = [];
+
+	constructor(
+		private readonly _proxy: MainThreadWebviewsShape,
+		public readonly viewType: string,
+		public readonly uri: vscode.Uri,
+		public readonly userData: unknown,
+		public readonly _capabilities: vscode.WebviewCustomEditorCapabilities,
+	) {
+		super();
+
+		// Hook up events
+		_capabilities.editing?.onDidEdit(edit => {
+			this.pushEdit(edit, this);
+		});
+	}
+
+	//#region Public API
+
+	#_onDidDispose = this._register(new Emitter<void>());
+	public readonly onDidDispose = this.#_onDidDispose.event;
+
+	//#endregion
+
+	dispose() {
+		this.#_onDidDispose.fire();
+		super.dispose();
+	}
+
+	private pushEdit(edit: EditType, trigger: any) {
+		this.spliceEdits(edit);
+
+		this._currentEditIndex = this._edits.length - 1;
+		this.updateState();
+		// this._onApplyEdit.fire({ edits: [edit], trigger });
+	}
+
+	private updateState() {
+		const dirty = this._edits.length > 0 && this._savePoint !== this._currentEditIndex;
+		this._proxy.$onDidChangeCustomDocumentState(this.uri, this.viewType, { dirty });
+	}
+
+	private spliceEdits(editToInsert?: EditType) {
+		const start = this._currentEditIndex + 1;
+		const toRemove = this._edits.length - this._currentEditIndex;
+
+		editToInsert
+			? this._edits.splice(start, toRemove, editToInsert)
+			: this._edits.splice(start, toRemove);
+	}
+
+	revert() {
+		const editing = this.getEditingCapability();
+		if (this._currentEditIndex === this._savePoint) {
+			return true;
+		}
+
+		if (this._currentEditIndex >= this._savePoint) {
+			const editsToUndo = this._edits.slice(this._savePoint, this._currentEditIndex);
+			editing.undoEdits(editsToUndo.reverse());
+		} else if (this._currentEditIndex < this._savePoint) {
+			const editsToRedo = this._edits.slice(this._currentEditIndex, this._savePoint);
+			editing.applyEdits(editsToRedo);
+		}
+
+		this._currentEditIndex = this._savePoint;
+		this.spliceEdits();
+
+		this.updateState();
+		return true;
+	}
+
+	undo() {
+		const editing = this.getEditingCapability();
+		if (this._currentEditIndex < 0) {
+			// nothing to undo
+			return;
+		}
+
+		const undoneEdit = this._edits[this._currentEditIndex];
+		--this._currentEditIndex;
+		editing.undoEdits([undoneEdit]);
+		this.updateState();
+	}
+
+	redo() {
+		const editing = this.getEditingCapability();
+		if (this._currentEditIndex >= this._edits.length - 1) {
+			// nothing to redo
+			return;
+		}
+
+		++this._currentEditIndex;
+		const redoneEdit = this._edits[this._currentEditIndex];
+		editing.applyEdits([redoneEdit]);
+		this.updateState();
+	}
+
+	save() {
+		return this.getEditingCapability().save();
+	}
+
+	saveAs(target: vscode.Uri) {
+		return this.getEditingCapability().saveAs(target);
+	}
+
+	backup(cancellation: CancellationToken): boolean | PromiseLike<boolean> {
+		throw new Error('Method not implemented.');
+	}
+
+	private getEditingCapability(): vscode.WebviewCustomEditorEditingCapability {
+		if (!this._capabilities.editing) {
+			throw new Error('Document is not editable');
+		}
+		return this._capabilities.editing;
+	}
+}
+
+class WebviewDocumentStore {
+	private readonly _documents = new Map<string, WebviewEditorCustomDocument>();
+
+	public get(viewType: string, resource: vscode.Uri): WebviewEditorCustomDocument | undefined {
+		return this._documents.get(this.key(viewType, resource));
+	}
+
+	public add(document: WebviewEditorCustomDocument) {
+		const key = this.key(document.viewType, document.uri);
+		if (this._documents.has(key)) {
+			throw new Error(`Document already exists for viewType:${document.viewType} resource:${document.uri}`);
+		}
+		this._documents.set(key, document);
+	}
+
+	public delete(document: WebviewEditorCustomDocument) {
+		const key = this.key(document.viewType, document.uri);
+		this._documents.delete(key);
+	}
+
+	private key(viewType: string, resource: vscode.Uri): string {
+		return `${viewType}@@@${resource.toString}`;
+	}
+}
+
+const enum WebviewEditorType {
+	Text,
+	Custom
+}
+
+type ProviderEntry = {
+	readonly extension: IExtensionDescription;
+	readonly type: WebviewEditorType.Text;
+	readonly provider: vscode.WebviewTextEditorProvider;
+} | {
+	readonly extension: IExtensionDescription;
+	readonly type: WebviewEditorType.Custom;
+	readonly provider: vscode.WebviewCustomEditorProvider;
+};
+
+class EditorProviderStore {
+	private readonly _providers = new Map<string, ProviderEntry>();
+
+	public addTextProvider(viewType: string, extension: IExtensionDescription, provider: vscode.WebviewTextEditorProvider): vscode.Disposable {
+		return this.add(WebviewEditorType.Text, viewType, extension, provider);
+	}
+
+	public addCustomProvider(viewType: string, extension: IExtensionDescription, provider: vscode.WebviewCustomEditorProvider): vscode.Disposable {
+		return this.add(WebviewEditorType.Custom, viewType, extension, provider);
+	}
+
+	public get(viewType: string): ProviderEntry | undefined {
+		return this._providers.get(viewType);
+	}
+
+	private add(type: WebviewEditorType, viewType: string, extension: IExtensionDescription, provider: vscode.WebviewTextEditorProvider | vscode.WebviewCustomEditorProvider): vscode.Disposable {
+		if (this._providers.has(viewType)) {
+			throw new Error(`Provider for viewType:${viewType} already registered`);
+		}
+		this._providers.set(viewType, { type, extension, provider } as ProviderEntry);
+		return new VSCodeDisposable(() => this._providers.delete(viewType));
+	}
+}
+
 export class ExtHostWebviews implements ExtHostWebviewsShape {

 	private static newHandle(): WebviewPanelHandle {
@@ -259,18 +446,17 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 		readonly extension: IExtensionDescription;
 	}>();

-	private readonly _editorProviders = new Map<string, {
-		readonly provider: vscode.WebviewCustomEditorProvider;
-		readonly extension: IExtensionDescription;
-	}>();
+	private readonly _editorProviders = new EditorProviderStore();

-	private readonly _edits = new Cache<unknown>('edits');
+	private readonly _documents = new WebviewDocumentStore();

 	constructor(
 		mainContext: IMainContext,
 		private readonly initData: WebviewInitData,
 		private readonly workspace: IExtHostWorkspace | undefined,
 		private readonly _logService: ILogService,
+		private readonly _deprecationService: IExtHostApiDeprecationService,
+		private readonly _extHostDocuments: ExtHostDocuments,
 	) {
 		this._proxy = mainContext.getProxy(MainContext.MainThreadWebviews);
 	}
@@ -289,9 +475,9 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 		};

 		const handle = ExtHostWebviews.newHandle();
-		this._proxy.$createWebviewPanel({ id: extension.identifier, location: extension.extensionLocation }, handle, viewType, title, webviewShowOptions, convertWebviewOptions(extension, this.workspace, options));
+		this._proxy.$createWebviewPanel(toExtensionData(extension), handle, viewType, title, webviewShowOptions, convertWebviewOptions(extension, this.workspace, options));

-		const webview = new ExtHostWebview(handle, this._proxy, options, this.initData, this.workspace, extension, this._logService);
+		const webview = new ExtHostWebview(handle, this._proxy, options, this.initData, this.workspace, extension, this._deprecationService);
 		const panel = new ExtHostWebviewEditor(handle, this._proxy, viewType, title, viewColumn, options, webview);
 		this._webviewPanels.set(handle, panel);
 		return panel;
@@ -315,31 +501,45 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 		});
 	}

+	public registerWebviewTextEditorProvider(
+		extension: IExtensionDescription,
+		viewType: string,
+		provider: vscode.WebviewTextEditorProvider,
+		options: vscode.WebviewPanelOptions | undefined = {}
+	): vscode.Disposable {
+		const unregisterProvider = this._editorProviders.addTextProvider(viewType, extension, provider);
+		this._proxy.$registerTextEditorProvider(toExtensionData(extension), viewType, options);
+
+		return new VSCodeDisposable(() => {
+			unregisterProvider.dispose();
+			this._proxy.$unregisterEditorProvider(viewType);
+		});
+	}
+
 	public registerWebviewCustomEditorProvider(
 		extension: IExtensionDescription,
 		viewType: string,
 		provider: vscode.WebviewCustomEditorProvider,
-		options?: vscode.WebviewPanelOptions,
+		options: vscode.WebviewPanelOptions | undefined = {},
 	): vscode.Disposable {
-		if (this._editorProviders.has(viewType)) {
-			throw new Error(`Editor provider for '${viewType}' already registered`);
-		}
-		this._editorProviders.set(viewType, { extension, provider, });
-
-		this._proxy.$registerEditorProvider({ id: extension.identifier, location: extension.extensionLocation }, viewType, options || {}, this.getCapabilites(provider));
-
-		// Hook up events
-		provider?.editingDelegate?.onEdit(({ edit, resource }) => {
-			const id = this._edits.add([edit]);
-			this._proxy.$onEdit(resource, viewType, id);
-		});
+		const unregisterProvider = this._editorProviders.addCustomProvider(viewType, extension, provider);
+		this._proxy.$registerCustomEditorProvider(toExtensionData(extension), viewType, options);

 		return new VSCodeDisposable(() => {
-			this._editorProviders.delete(viewType);
+			unregisterProvider.dispose();
 			this._proxy.$unregisterEditorProvider(viewType);
 		});
 	}

+	public createWebviewEditorCustomDocument<UserDataType>(
+		viewType: string,
+		resource: vscode.Uri,
+		userData: UserDataType,
+		capabilities: vscode.WebviewCustomEditorCapabilities,
+	): vscode.WebviewEditorCustomDocument<UserDataType> {
+		return Object.seal(new WebviewEditorCustomDocument(this._proxy, viewType, resource, userData, capabilities) as vscode.WebviewEditorCustomDocument<UserDataType>);
+	}
+
 	public $onMessage(
 		handle: WebviewPanelHandle,
 		message: any
@@ -414,12 +614,46 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 		}
 		const { serializer, extension } = entry;

-		const webview = new ExtHostWebview(webviewHandle, this._proxy, options, this.initData, this.workspace, extension, this._logService);
+		const webview = new ExtHostWebview(webviewHandle, this._proxy, options, this.initData, this.workspace, extension, this._deprecationService);
 		const revivedPanel = new ExtHostWebviewEditor(webviewHandle, this._proxy, viewType, title, typeof position === 'number' && position >= 0 ? typeConverters.ViewColumn.to(position) : undefined, options, webview);
 		this._webviewPanels.set(webviewHandle, revivedPanel);
 		await serializer.deserializeWebviewPanel(revivedPanel, state);
 	}

+	async $createWebviewCustomEditorDocument(resource: UriComponents, viewType: string) {
+		const entry = this._editorProviders.get(viewType);
+		if (!entry) {
+			throw new Error(`No provider found for '${viewType}'`);
+		}
+
+		if (entry.type !== WebviewEditorType.Custom) {
+			throw new Error(`Invalid provide type for '${viewType}'`);
+		}
+
+		const revivedResource = URI.revive(resource);
+		const document = await entry.provider.provideWebviewCustomEditorDocument(revivedResource) as WebviewEditorCustomDocument;
+		this._documents.add(document);
+		return {
+			editable: !!document._capabilities.editing
+		};
+	}
+
+	async $disposeWebviewCustomEditorDocument(resource: UriComponents, viewType: string): Promise<void> {
+		const entry = this._editorProviders.get(viewType);
+		if (!entry) {
+			throw new Error(`No provider found for '${viewType}'`);
+		}
+
+		if (entry.type !== WebviewEditorType.Custom) {
+			throw new Error(`Invalid provider type for '${viewType}'`);
+		}
+
+		const revivedResource = URI.revive(resource);
+		const document = this.getDocument(viewType, revivedResource);
+		this._documents.delete(document);
+		document.dispose();
+	}
+
 	async $resolveWebviewEditor(
 		resource: UriComponents,
 		handle: WebviewPanelHandle,
@@ -430,81 +664,79 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 	): Promise<void> {
 		const entry = this._editorProviders.get(viewType);
 		if (!entry) {
-			return Promise.reject(new Error(`No provider found for '${viewType}'`));
+			throw new Error(`No provider found for '${viewType}'`);
 		}

-		const { provider, extension } = entry;
-		const webview = new ExtHostWebview(handle, this._proxy, options, this.initData, this.workspace, extension, this._logService);
+		const webview = new ExtHostWebview(handle, this._proxy, options, this.initData, this.workspace, entry.extension, this._deprecationService);
 		const revivedPanel = new ExtHostWebviewEditor(handle, this._proxy, viewType, title, typeof position === 'number' && position >= 0 ? typeConverters.ViewColumn.to(position) : undefined, options, webview);
 		this._webviewPanels.set(handle, revivedPanel);
+
 		const revivedResource = URI.revive(resource);
-		await provider.resolveWebviewEditor(revivedResource, revivedPanel);
-	}

-	$undoEdits(resourceComponents: UriComponents, viewType: string, editIds: readonly number[]): void {
-		const provider = this.getEditorProvider(viewType);
-		if (!provider?.editingDelegate) {
-			return;
-		}
-
-		const resource = URI.revive(resourceComponents);
-		const edits = editIds.map(id => this._edits.get(id, 0));
-		provider.editingDelegate.undoEdits(resource, edits);
-	}
-
-	$applyEdits(resourceComponents: UriComponents, viewType: string, editIds: readonly number[]): void {
-		const provider = this.getEditorProvider(viewType);
-		if (!provider?.editingDelegate) {
-			return;
-		}
-
-		const resource = URI.revive(resourceComponents);
-		const edits = editIds.map(id => this._edits.get(id, 0));
-		provider.editingDelegate.applyEdits(resource, edits);
-	}
-
-	$disposeEdits(editIds: readonly number[]): void {
-		for (const edit of editIds) {
-			this._edits.delete(edit);
+		switch (entry.type) {
+			case WebviewEditorType.Custom:
+				{
+					const document = this.getDocument(viewType, revivedResource);
+					return entry.provider.resolveWebviewCustomEditor(document, revivedPanel);
+				}
+			case WebviewEditorType.Text:
+				{
+					await this._extHostDocuments.ensureDocumentData(revivedResource);
+					const document = this._extHostDocuments.getDocument(revivedResource);
+					return entry.provider.resolveWebviewTextEditor(document, revivedPanel);
+				}
+			default:
+				{
+					throw new Error('Unknown webview provider type');
+				}
 		}
 	}

-	async $onSave(resource: UriComponents, viewType: string): Promise<void> {
-		const provider = this.getEditorProvider(viewType);
-		return provider?.editingDelegate?.save(URI.revive(resource));
+	async $undo(resourceComponents: UriComponents, viewType: string): Promise<void> {
+		const document = this.getDocument(viewType, resourceComponents);
+		document.undo();
 	}

-	async $onSaveAs(resource: UriComponents, viewType: string, targetResource: UriComponents): Promise<void> {
-		const provider = this.getEditorProvider(viewType);
-		return provider?.editingDelegate?.saveAs(URI.revive(resource), URI.revive(targetResource));
+	async $redo(resourceComponents: UriComponents, viewType: string): Promise<void> {
+		const document = this.getDocument(viewType, resourceComponents);
+		document.redo();
 	}

-	async $backup(resource: UriComponents, viewType: string, cancellation: CancellationToken): Promise<boolean> {
-		const provider = this.getEditorProvider(viewType);
-		if (!provider?.editingDelegate?.backup) {
-			return false;
-		}
-		return provider.editingDelegate.backup(URI.revive(resource), cancellation);
+	async $revert(resourceComponents: UriComponents, viewType: string): Promise<void> {
+		const document = this.getDocument(viewType, resourceComponents);
+		document.revert();
+	}
+
+	async $onSave(resourceComponents: UriComponents, viewType: string): Promise<void> {
+		const document = this.getDocument(viewType, resourceComponents);
+		document.save();
+	}
+
+	async $onSaveAs(resourceComponents: UriComponents, viewType: string, targetResource: UriComponents): Promise<void> {
+		const document = this.getDocument(viewType, resourceComponents);
+		return document.saveAs(URI.revive(targetResource));
+	}
+
+	async $backup(resourceComponents: UriComponents, viewType: string, cancellation: CancellationToken): Promise<boolean> {
+		const document = this.getDocument(viewType, resourceComponents);
+		return document.backup(cancellation);
 	}

 	private getWebviewPanel(handle: WebviewPanelHandle): ExtHostWebviewEditor | undefined {
 		return this._webviewPanels.get(handle);
 	}

-	private getEditorProvider(viewType: string): vscode.WebviewCustomEditorProvider | undefined {
-		return this._editorProviders.get(viewType)?.provider;
+	private getDocument(viewType: string, resource: UriComponents): WebviewEditorCustomDocument {
+		const document = this._documents.get(viewType, URI.revive(resource));
+		if (!document) {
+			throw new Error('No webview editor custom document found');
+		}
+		return document;
 	}
+}

-	private getCapabilites(capabilities: vscode.WebviewCustomEditorProvider) {
-		const declaredCapabilites: WebviewEditorCapabilities[] = [];
-		if (capabilities.editingDelegate) {
-			declaredCapabilites.push(WebviewEditorCapabilities.Editable);
-		}
-		if (capabilities.editingDelegate?.backup) {
-			declaredCapabilites.push(WebviewEditorCapabilities.SupportsHotExit);
-		}
-		return declaredCapabilites;
-	}
+function toExtensionData(extension: IExtensionDescription): WebviewExtensionDescription {
+	return { id: extension.identifier, location: extension.extensionLocation };
 }

 function convertWebviewOptions(
--- a/src/vs/workbench/api/common/shared/tasks.ts
+++ b/src/vs/workbench/api/common/shared/tasks.ts
@@ -78,7 +78,7 @@ export interface TaskSourceDTO {

 export interface TaskHandleDTO {
 	id: string;
-	workspaceFolder: UriComponents;
+	workspaceFolder: UriComponents | string;
 }

 export interface TaskDTO {