Merge from vscode 1ec43773e37997841c5af42b33ddb180e9735bf2

src/vs/workbench/api/common/extHostNotebook.ts

@@ -3,17 +3,17 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import * as vscode from 'vscode';
 import { readonly } from 'vs/base/common/errors';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
 import { ISplice } from 'vs/base/common/sequence';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
-import { CellKind, CellOutputKind, ExtHostNotebookShape, ICellDto, IMainContext, MainContext, MainThreadNotebookShape, NotebookCellOutputsSplice, NotebookCellsSplice } from 'vs/workbench/api/common/extHost.protocol';
+import { CellKind, CellOutputKind, ExtHostNotebookShape, IMainContext, MainContext, MainThreadNotebookShape, NotebookCellOutputsSplice } from 'vs/workbench/api/common/extHost.protocol';
 import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
 import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
-import { CellUri, diff, IErrorOutput, INotebookDisplayOrder, IOrderedMimeType, IOutput, IStreamOutput, ITransformedDisplayOutputDto, mimeTypeSupportedByCore, sortMimeTypes } from 'vs/workbench/contrib/notebook/common/notebookCommon';
-import * as vscode from 'vscode';
+import { CellEditType, CellUri, diff, ICellEditOperation, ICellInsertEdit, IErrorOutput, INotebookDisplayOrder, INotebookEditData, IOrderedMimeType, IStreamOutput, ITransformedDisplayOutputDto, mimeTypeSupportedByCore, NotebookCellsChangedEvent, NotebookCellsSplice2, sortMimeTypes, ICellDeleteEdit } from 'vs/workbench/contrib/notebook/common/notebookCommon';
 import { Disposable as VSCodeDisposable } from './extHostTypes';
 
 interface IObservable<T> {
@@ -44,7 +44,8 @@ const notebookDocumentMetadataDefaults: vscode.NotebookDocumentMetadata = {
 };
 
 export class ExtHostCell extends Disposable implements vscode.NotebookCell {
-	public source: string[];
+
+	private originalSource: string[];
 	private _outputs: any[];
 	private _onDidChangeOutputs = new Emitter<ISplice<vscode.CellOutput>[]>();
 	onDidChangeOutputs: Event<ISplice<vscode.CellOutput>[]> = this._onDidChangeOutputs.event;
@@ -55,21 +56,28 @@ export class ExtHostCell extends Disposable implements vscode.NotebookCell {
 
 	private _metadataChangeListener: IDisposable;
 
+	get source() {
+		if (this._textDocument && this._initalVersion !== this._textDocument?.version) {
+			return this._textDocument.getText();
+		} else {
+			return this.originalSource.join('\n');
+		}
+	}
+
 	constructor(
 		private viewType: string,
 		private documentUri: URI,
 		readonly handle: number,
 		readonly uri: URI,
 		private _content: string,
-		public cellKind: CellKind,
+		public readonly cellKind: CellKind,
 		public language: string,
 		outputs: any[],
 		_metadata: vscode.NotebookCellMetadata | undefined,
 		private _proxy: MainThreadNotebookShape
 	) {
 		super();
-
-		this.source = this._content.split(/\r|\n|\r\n/g);
+		this.originalSource = this._content.split(/\r|\n|\r\n/g);
 		this._outputs = outputs;
 
 		const observableMetadata = getObservable(_metadata || {} as any);
@@ -106,7 +114,7 @@ export class ExtHostCell extends Disposable implements vscode.NotebookCell {
 		return this._metadata;
 	}
 
-	set metadata(newMetadata: vscode.NotebookCellMetadata | undefined) {
+	set metadata(newMetadata: vscode.NotebookCellMetadata) {
 		this._metadataChangeListener.dispose();
 		const observableMetadata = getObservable(newMetadata || {} as any); // TODO defaults
 		this._metadata = observableMetadata.proxy;
@@ -125,7 +133,7 @@ export class ExtHostCell extends Disposable implements vscode.NotebookCell {
 		if (this._textDocument && this._initalVersion !== this._textDocument?.version) {
 			return this._textDocument.getText();
 		} else {
-			return this.source.join('\n');
+			return this.originalSource.join('\n');
 		}
 	}
 
@@ -134,9 +142,9 @@ export class ExtHostCell extends Disposable implements vscode.NotebookCell {
 		this._initalVersion = this._textDocument.version;
 	}
 
-	detachTextDocument(document: vscode.TextDocument) {
+	detachTextDocument() {
 		if (this._textDocument && this._textDocument.version !== this._initalVersion) {
-			this.source = this._textDocument.getText().split(/\r|\n|\r\n/g);
+			this.originalSource = this._textDocument.getText().split(/\r|\n|\r\n/g);
 		}
 
 		this._textDocument = undefined;
@@ -156,29 +164,6 @@ export class ExtHostNotebookDocument extends Disposable implements vscode.Notebo
 		return this._cells;
 	}
 
-	set cells(newCells: ExtHostCell[]) {
-		let diffs = diff<ExtHostCell>(this._cells, newCells, (a) => {
-			return this._cellDisposableMapping.has(a.handle);
-		});
-
-		diffs.forEach(diff => {
-			for (let i = diff.start; i < diff.start + diff.deleteCount; i++) {
-				this._cellDisposableMapping.get(this._cells[i].handle)?.clear();
-				this._cellDisposableMapping.delete(this._cells[i].handle);
-			}
-
-			diff.toInsert.forEach(cell => {
-				this._cellDisposableMapping.set(cell.handle, new DisposableStore());
-				this._cellDisposableMapping.get(cell.handle)?.add(cell.onDidChangeOutputs((outputDiffs) => {
-					this.eventuallyUpdateCellOutputs(cell, outputDiffs);
-				}));
-			});
-		});
-
-		this._cells = newCells;
-		this.eventuallyUpdateCells(diffs);
-	}
-
 	private _languages: string[] = [];
 
 	get languages() {
@@ -211,8 +196,15 @@ export class ExtHostNotebookDocument extends Disposable implements vscode.Notebo
 		this._displayOrder = newOrder;
 	}
 
+	private _versionId = 0;
+
+	get versionId() {
+		return this._versionId;
+	}
+
 	constructor(
 		private readonly _proxy: MainThreadNotebookShape,
+		private _documentsAndEditors: ExtHostDocumentsAndEditors,
 		public viewType: string,
 		public uri: URI,
 		public renderingHandler: ExtHostNotebookOutputRenderingHandler
@@ -229,51 +221,47 @@ export class ExtHostNotebookDocument extends Disposable implements vscode.Notebo
 
 	get isDirty() { return false; }
 
-	eventuallyUpdateCells(diffs: ISplice<ExtHostCell>[]) {
-		let renderers = new Set<number>();
-		let diffDtos: NotebookCellsSplice[] = [];
+	accpetModelChanged(event: NotebookCellsChangedEvent) {
+		this.$spliceNotebookCells(event.changes);
+		this._versionId = event.versionId;
+	}
 
-		diffDtos = diffs.map(diff => {
-			let inserts = diff.toInsert;
+	private $spliceNotebookCells(splices: NotebookCellsSplice2[]): void {
+		if (!splices.length) {
+			return;
+		}
 
-			let cellDtos = inserts.map(cell => {
-				let outputs: IOutput[] = [];
-				if (cell.outputs.length) {
-					outputs = cell.outputs.map(output => {
-						if (output.outputKind === CellOutputKind.Rich) {
-							const ret = this.transformMimeTypes(cell, output);
+		splices.reverse().forEach(splice => {
+			let cellDtos = splice[2];
+			let newCells = cellDtos.map(cell => {
+				const extCell = new ExtHostCell(this.viewType, this.uri, cell.handle, URI.revive(cell.uri), cell.source.join('\n'), cell.cellKind, cell.language, cell.outputs, cell.metadata, this._proxy);
+				const document = this._documentsAndEditors.getDocument(URI.revive(cell.uri));
 
-							if (ret.orderedMimeTypes[ret.pickedMimeTypeIndex].isResolved) {
-								renderers.add(ret.orderedMimeTypes[ret.pickedMimeTypeIndex].rendererId!);
-							}
-							return ret;
-						} else {
-							return output as IStreamOutput | IErrorOutput;
-						}
-					});
+				if (document) {
+					extCell.attachTextDocument(document.document);
 				}
 
-				return {
-					uri: cell.uri,
-					handle: cell.handle,
-					source: cell.source,
-					language: cell.language,
-					cellKind: cell.cellKind,
-					outputs: outputs,
-					metadata: cell.metadata,
-					isDirty: false
-				};
+				if (!this._cellDisposableMapping.has(extCell.handle)) {
+					this._cellDisposableMapping.set(extCell.handle, new DisposableStore());
+				}
+
+				let store = this._cellDisposableMapping.get(extCell.handle)!;
+
+				store.add(extCell.onDidChangeOutputs((diffs) => {
+					this.eventuallyUpdateCellOutputs(extCell, diffs);
+				}));
+
+				return extCell;
 			});
 
-			return [diff.start, diff.deleteCount, cellDtos];
-		});
+			for (let j = splice[0]; j < splice[0] + splice[1]; j++) {
+				this._cellDisposableMapping.get(this.cells[j].handle)?.dispose();
+				this._cellDisposableMapping.delete(this.cells[j].handle);
 
-		this._proxy.$spliceNotebookCells(
-			this.viewType,
-			this.uri,
-			diffDtos,
-			Array.from(renderers)
-		);
+			}
+
+			this.cells.splice(splice[0], splice[1], ...newCells);
+		});
 	}
 
 	eventuallyUpdateCellOutputs(cell: ExtHostCell, diffs: ISplice<vscode.CellOutput>[]) {
@@ -283,7 +271,7 @@ export class ExtHostNotebookDocument extends Disposable implements vscode.Notebo
 
 			let transformedOutputs = outputs.map(output => {
 				if (output.outputKind === CellOutputKind.Rich) {
-					const ret = this.transformMimeTypes(cell, output);
+					const ret = this.transformMimeTypes(output);
 
 					if (ret.orderedMimeTypes[ret.pickedMimeTypeIndex].isResolved) {
 						renderers.add(ret.orderedMimeTypes[ret.pickedMimeTypeIndex].rendererId!);
@@ -300,35 +288,7 @@ export class ExtHostNotebookDocument extends Disposable implements vscode.Notebo
 		this._proxy.$spliceNotebookCellOutputs(this.viewType, this.uri, cell.handle, outputDtos, Array.from(renderers));
 	}
 
-	insertCell(index: number, cell: ExtHostCell) {
-		this.cells.splice(index, 0, cell);
-
-		if (!this._cellDisposableMapping.has(cell.handle)) {
-			this._cellDisposableMapping.set(cell.handle, new DisposableStore());
-		}
-
-		let store = this._cellDisposableMapping.get(cell.handle)!;
-
-		store.add(cell.onDidChangeOutputs((diffs) => {
-			this.eventuallyUpdateCellOutputs(cell, diffs);
-		}));
-	}
-
-	deleteCell(index: number): boolean {
-		if (index >= this.cells.length) {
-			return false;
-		}
-
-		let cell = this.cells[index];
-		this._cellDisposableMapping.get(cell.handle)?.dispose();
-		this._cellDisposableMapping.delete(cell.handle);
-
-		this.cells.splice(index, 1);
-		return true;
-	}
-
-
-	transformMimeTypes(cell: ExtHostCell, output: vscode.CellDisplayOutput): ITransformedDisplayOutputDto {
+	transformMimeTypes(output: vscode.CellDisplayOutput): ITransformedDisplayOutputDto {
 		let mimeTypes = Object.keys(output.data);
 
 		// TODO@rebornix, the document display order might be assigned a bit later. We need to postpone sending the outputs to the core side.
@@ -341,7 +301,7 @@ export class ExtHostNotebookDocument extends Disposable implements vscode.Notebo
 			let handlers = this.renderingHandler.findBestMatchedRenderer(mimeType);
 
 			if (handlers.length) {
-				let renderedOutput = handlers[0].render(this, cell, output, mimeType);
+				let renderedOutput = handlers[0].render(this, output, mimeType);
 
 				orderMimeTypes.push({
 					mimeType: mimeType,
@@ -395,14 +355,84 @@ export class ExtHostNotebookDocument extends Disposable implements vscode.Notebo
 	detachCellTextDocument(textDocument: vscode.TextDocument) {
 		let cell = this.cells.find(cell => cell.uri.toString() === textDocument.uri.toString());
 		if (cell) {
-			cell.detachTextDocument(textDocument);
+			cell.detachTextDocument();
 		}
 	}
 }
 
+export class NotebookEditorCellEdit {
+	private _finalized: boolean = false;
+	private readonly _documentVersionId: number;
+	private _collectedEdits: ICellEditOperation[] = [];
+	private _renderers = new Set<number>();
+
+	constructor(
+		readonly editor: ExtHostNotebookEditor
+	) {
+		this._documentVersionId = editor.document.versionId;
+	}
+
+	finalize(): INotebookEditData {
+		this._finalized = true;
+		return {
+			documentVersionId: this._documentVersionId,
+			edits: this._collectedEdits,
+			renderers: Array.from(this._renderers)
+		};
+	}
+
+	private _throwIfFinalized() {
+		if (this._finalized) {
+			throw new Error('Edit is only valid while callback runs');
+		}
+	}
+
+	insert(index: number, content: string, language: string, type: CellKind, outputs: vscode.CellOutput[], metadata: vscode.NotebookCellMetadata | undefined): void {
+		this._throwIfFinalized();
+
+		let cell = {
+			source: [content],
+			language,
+			cellKind: type,
+			outputs: (outputs as any[]), // TODO@rebornix
+			metadata
+		};
+
+		const transformedOutputs = outputs.map(output => {
+			if (output.outputKind === CellOutputKind.Rich) {
+				const ret = this.editor.document.transformMimeTypes(output);
+
+				if (ret.orderedMimeTypes[ret.pickedMimeTypeIndex].isResolved) {
+					this._renderers.add(ret.orderedMimeTypes[ret.pickedMimeTypeIndex].rendererId!);
+				}
+				return ret;
+			} else {
+				return output as IStreamOutput | IErrorOutput;
+			}
+		});
+
+		cell.outputs = transformedOutputs;
+
+		this._collectedEdits.push({
+			editType: CellEditType.Insert,
+			index,
+			cells: [cell]
+		});
+	}
+
+	delete(index: number): void {
+		this._throwIfFinalized();
+
+		this._collectedEdits.push({
+			editType: CellEditType.Delete,
+			index,
+			count: 1
+		});
+	}
+}
+
 export class ExtHostNotebookEditor extends Disposable implements vscode.NotebookEditor {
 	private _viewColumn: vscode.ViewColumn | undefined;
-	private static _cellhandlePool: number = 0;
 	onDidReceiveMessage: vscode.Event<any> = this._onDidReceiveMessage.event;
 
 	constructor(
@@ -438,11 +468,52 @@ export class ExtHostNotebookEditor extends Disposable implements vscode.Notebook
 		}));
 	}
 
-	createCell(content: string, language: string, type: CellKind, outputs: vscode.CellOutput[], metadata: vscode.NotebookCellMetadata | undefined): vscode.NotebookCell {
-		const handle = ExtHostNotebookEditor._cellhandlePool++;
-		const uri = CellUri.generate(this.document.uri, handle);
-		const cell = new ExtHostCell(this.viewType, this.uri, handle, uri, content, type, language, outputs, metadata, this._proxy);
-		return cell;
+	edit(callback: (editBuilder: NotebookEditorCellEdit) => void): Thenable<boolean> {
+		const edit = new NotebookEditorCellEdit(this);
+		callback(edit);
+		return this._applyEdit(edit);
+	}
+
+	private _applyEdit(editBuilder: NotebookEditorCellEdit): Promise<boolean> {
+		const editData = editBuilder.finalize();
+
+		// return when there is nothing to do
+		if (editData.edits.length === 0) {
+			return Promise.resolve(true);
+		}
+
+		let compressedEdits: ICellEditOperation[] = [];
+		let compressedEditsIndex = -1;
+
+		for (let i = 0; i < editData.edits.length; i++) {
+			if (compressedEditsIndex < 0) {
+				compressedEdits.push(editData.edits[i]);
+				compressedEditsIndex++;
+				continue;
+			}
+
+			let prevIndex = compressedEditsIndex;
+			let prev = compressedEdits[prevIndex];
+
+			if (prev.editType === CellEditType.Insert && editData.edits[i].editType === CellEditType.Insert) {
+				if (prev.index === editData.edits[i].index) {
+					prev.cells.push(...(editData.edits[i] as ICellInsertEdit).cells);
+					continue;
+				}
+			}
+
+			if (prev.editType === CellEditType.Delete && editData.edits[i].editType === CellEditType.Delete) {
+				if (prev.index === editData.edits[i].index) {
+					prev.count += (editData.edits[i] as ICellDeleteEdit).count;
+					continue;
+				}
+			}
+
+			compressedEdits.push(editData.edits[i]);
+			compressedEditsIndex++;
+		}
+
+		return this._proxy.$tryApplyEdits(this.viewType, this.uri, editData.documentVersionId, compressedEdits, editData.renderers);
 	}
 
 	get viewColumn(): vscode.ViewColumn | undefined {
@@ -480,8 +551,8 @@ export class ExtHostNotebookOutputRenderer {
 		return false;
 	}
 
-	render(document: ExtHostNotebookDocument, cell: ExtHostCell, output: vscode.CellOutput, mimeType: string): string {
-		let html = this.renderer.render(document, cell, output, mimeType);
+	render(document: ExtHostNotebookDocument, output: vscode.CellOutput, mimeType: string): string {
+		let html = this.renderer.render(document, output, mimeType);
 
 		return html;
 	}
@@ -584,7 +655,7 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 
 		if (provider) {
 			if (!this._documents.has(URI.revive(uri).toString())) {
-				let document = new ExtHostNotebookDocument(this._proxy, viewType, URI.revive(uri), this);
+				let document = new ExtHostNotebookDocument(this._proxy, this._documentsAndEditors, viewType, URI.revive(uri), this);
 				await this._proxy.$createNotebookDocument(
 					document.handle,
 					viewType,
@@ -632,55 +703,6 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 		return provider.provider.executeCell(document!, cell);
 	}
 
-	async $createEmptyCell(viewType: string, uri: URI, index: number, language: string, type: CellKind): Promise<ICellDto | undefined> {
-		let provider = this._notebookProviders.get(viewType);
-
-		if (provider) {
-			let editor = this._editors.get(URI.revive(uri).toString());
-			let document = this._documents.get(URI.revive(uri).toString());
-
-			let rawCell = editor?.editor.createCell('', language, type, [], { editable: true, runnable: true }) as ExtHostCell;
-			document?.insertCell(index, rawCell!);
-
-			let allDocuments = this._documentsAndEditors.allDocuments();
-			for (let { document: textDocument } of allDocuments) {
-				let data = CellUri.parse(textDocument.uri);
-				if (data) {
-					if (uri.toString() === data.notebook.toString() && textDocument.uri.toString() === rawCell.uri.toString()) {
-						rawCell.attachTextDocument(textDocument);
-					}
-				}
-			}
-			return {
-				uri: rawCell.uri,
-				handle: rawCell.handle,
-				source: rawCell.source,
-				language: rawCell.language,
-				cellKind: rawCell.cellKind,
-				metadata: rawCell.metadata,
-				outputs: []
-			};
-		}
-
-		return undefined; // {{SQL CARBON EDIT}} strict-null-check
-	}
-
-	async $deleteCell(viewType: string, uri: UriComponents, index: number): Promise<boolean> {
-		let provider = this._notebookProviders.get(viewType);
-
-		if (!provider) {
-			return false;
-		}
-
-		let document = this._documents.get(URI.revive(uri).toString());
-
-		if (document) {
-			return document.deleteCell(index);
-		}
-
-		return false;
-	}
-
 	async $saveNotebook(viewType: string, uri: UriComponents): Promise<boolean> {
 		let provider = this._notebookProviders.get(viewType);
 		let document = this._documents.get(URI.revive(uri).toString());
@@ -732,4 +754,13 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 			editor.onDidReceiveMessage.fire(message);
 		}
 	}
+
+	$acceptModelChanged(uriComponents: UriComponents, event: NotebookCellsChangedEvent): void {
+		let editor = this._editors.get(URI.revive(uriComponents).toString());
+
+		if (editor) {
+			editor.editor.document.accpetModelChanged(event);
+		}
+
+	}
 }