Merge from vscode fcf3346a8e9f5ee1e00674461d9e2c2292a14ee3 (#12295)

* Merge from vscode fcf3346a8e9f5ee1e00674461d9e2c2292a14ee3 * Fix test build break * Update distro * Fix build errors * Update distro * Update REH build file * Update build task names for REL * Fix product build yaml * Fix product REH task name * Fix type in task name * Update linux build step * Update windows build tasks * Turn off server publish * Disable REH * Fix typo * Bump distro * Update vscode tests * Bump distro * Fix type in disto * Bump distro * Turn off docker build * Remove docker step from release Co-authored-by: ADS Merger <andresse@microsoft.com> Co-authored-by: Karl Burtram <karlb@microsoft.com>
2026-01-15 17:22:25 -05:00 · 2020-10-03 14:42:05 -04:00
parent 58d02b76db
commit 6ff1e3866b
687 changed files with 10507 additions and 9104 deletions
--- a/src/vs/workbench/api/browser/mainThreadNotebook.ts
+++ b/src/vs/workbench/api/browser/mainThreadNotebook.ts
@@ -7,18 +7,22 @@ import * as DOM from 'vs/base/browser/dom';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { Emitter } from 'vs/base/common/event';
 import { combinedDisposable, Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
+import { ResourceMap } from 'vs/base/common/map';
+import { Schemas } from 'vs/base/common/network';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ILogService } from 'vs/platform/log/common/log';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { INotebookEditor } from 'vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { NotebookCellTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
 import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookTextModel';
 import { INotebookCellStatusBarService } from 'vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
-import { ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, CellEditType, CellKind, DisplayOrderKey, ICellEditOperation, ICellRange, IEditor, INotebookDocumentFilter, NotebookCellMetadata, NotebookCellOutputsSplice, NotebookDocumentMetadata, NOTEBOOK_DISPLAY_ORDER, TransientMetadata } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+import { ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, CellEditType, DisplayOrderKey, ICellEditOperation, ICellRange, IEditor, IMainCellDto, INotebookDocumentFilter, NotebookCellOutputsSplice, NotebookCellsChangeType, NOTEBOOK_DISPLAY_ORDER, TransientMetadata } from 'vs/workbench/contrib/notebook/common/notebookCommon';
 import { IMainNotebookController, INotebookService } from 'vs/workbench/contrib/notebook/common/notebookService';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
-import { ExtHostContext, ExtHostNotebookShape, IExtHostContext, INotebookCellStatusBarEntryDto, INotebookDocumentsAndEditorsDelta, MainContext, MainThreadNotebookShape, NotebookEditorRevealType, NotebookExtensionDescription } from '../common/extHost.protocol';
+import { IWorkingCopyService } from 'vs/workbench/services/workingCopy/common/workingCopyService';
+import { ExtHostContext, ExtHostNotebookShape, IExtHostContext, INotebookCellStatusBarEntryDto, INotebookDocumentsAndEditorsDelta, INotebookModelAddedData, MainContext, MainThreadNotebookShape, NotebookEditorRevealType, NotebookExtensionDescription } from '../common/extHost.protocol';

 class DocumentAndEditorState {
 	static ofSets<T>(before: Set<T>, after: Set<T>): { removed: T[], added: T[] } {
@@ -58,7 +62,7 @@ class DocumentAndEditorState {
 			const apiEditors = [];
 			for (let id in after.textEditors) {
 				const editor = after.textEditors.get(id)!;
-				apiEditors.push({ id, documentUri: editor.uri!, selections: editor!.textModel!.selections, visibleRanges: editor.visibleRanges });
+				apiEditors.push({ id, documentUri: editor.uri!, selections: editor!.getSelectionHandles(), visibleRanges: editor.visibleRanges });
 			}

 			return {
@@ -72,7 +76,7 @@ class DocumentAndEditorState {
 		const addedAPIEditors = editorDelta.added.map(add => ({
 			id: add.getId(),
 			documentUri: add.uri!,
-			selections: add.textModel!.selections || [],
+			selections: add.getSelectionHandles(),
 			visibleRanges: add.visibleRanges
 		}));

@@ -84,10 +88,9 @@ class DocumentAndEditorState {
 		const visibleEditorDelta = DocumentAndEditorState.ofMaps(before.visibleEditors, after.visibleEditors);

 		return {
-			addedDocuments: documentDelta.added.map(e => {
+			addedDocuments: documentDelta.added.map((e: NotebookTextModel): INotebookModelAddedData => {
 				return {
 					viewType: e.viewType,
-					handle: e.handle,
 					uri: e.uri,
 					metadata: e.metadata,
 					versionId: e.versionId,
@@ -129,13 +132,13 @@ class DocumentAndEditorState {

@extHostNamedCustomer(MainContext.MainThreadNotebook)
 export class MainThreadNotebooks extends Disposable implements MainThreadNotebookShape {
-	private readonly _notebookProviders = new Map<string, IMainNotebookController>();
+	private readonly _notebookProviders = new Map<string, { controller: IMainNotebookController, disposable: IDisposable }>();
 	private readonly _notebookKernelProviders = new Map<number, { extension: NotebookExtensionDescription, emitter: Emitter<URI | undefined>, provider: IDisposable }>();
 	private readonly _proxy: ExtHostNotebookShape;
 	private _toDisposeOnEditorRemove = new Map<string, IDisposable>();
 	private _currentState?: DocumentAndEditorState;
 	private _editorEventListenersMapping: Map<string, DisposableStore> = new Map();
-	private _documentEventListenersMapping: Map<string, DisposableStore> = new Map();
+	private _documentEventListenersMapping: ResourceMap<DisposableStore> = new ResourceMap();
 	private readonly _cellStatusBarEntries: Map<number, IDisposable> = new Map();

 	constructor(
@@ -145,29 +148,21 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		@IEditorService private readonly editorService: IEditorService,
 		@IAccessibilityService private readonly accessibilityService: IAccessibilityService,
 		@ILogService private readonly logService: ILogService,
-		@INotebookCellStatusBarService private readonly cellStatusBarService: INotebookCellStatusBarService
+		@INotebookCellStatusBarService private readonly cellStatusBarService: INotebookCellStatusBarService,
+		@IWorkingCopyService private readonly _workingCopyService: IWorkingCopyService,
 	) {
 		super();
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostNotebook);
 		this.registerListeners();
 	}

-	async $tryApplyEdits(viewType: string, resource: UriComponents, modelVersionId: number, edits: ICellEditOperation[]): Promise<boolean> {
+	async $tryApplyEdits(_viewType: string, resource: UriComponents, modelVersionId: number, cellEdits: ICellEditOperation[]): Promise<boolean> {
 		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
-		if (textModel) {
-			this._notebookService.transformEditsOutputs(textModel, edits);
-			return textModel.applyEdit(modelVersionId, edits, true);
+		if (!textModel) {
+			return false;
 		}
-
-		return false;
-	}
-
-	async removeNotebookTextModel(uri: URI): Promise<void> {
-		// TODO@rebornix, remove cell should use emitDelta as well to ensure document/editor events are sent together
-		this._proxy.$acceptDocumentAndEditorsDelta({ removedDocuments: [uri] });
-		let textModelDisposableStore = this._documentEventListenersMapping.get(uri.toString());
-		textModelDisposableStore?.dispose();
-		this._documentEventListenersMapping.delete(URI.from(uri).toString());
+		this._notebookService.transformEditsOutputs(textModel, cellEdits);
+		return textModel.applyEdits(modelVersionId, cellEdits, true, undefined, () => undefined);
 	}

 	private _isDeltaEmpty(delta: INotebookDocumentsAndEditorsDelta) {
@@ -231,7 +226,12 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 			if (!this._editorEventListenersMapping.has(editor.getId())) {
 				const disposableStore = new DisposableStore();
 				disposableStore.add(editor.onDidChangeVisibleRanges(() => {
-					this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: { ranges: editor.visibleRanges } });
+					this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: { ranges: editor.visibleRanges }, selections: null });
+				}));
+
+				disposableStore.add(editor.onDidChangeSelection(() => {
+					const selectionHandles = editor.getSelectionHandles();
+					this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: null, selections: { selections: selectionHandles } });
 				}));

 				this._editorEventListenersMapping.set(editor.getId(), disposableStore);
@@ -256,40 +256,79 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 			notebookEditorAddedHandler(editor);
 		});

-		const notebookDocumentAddedHandler = (doc: URI) => {
-			if (!this._editorEventListenersMapping.has(doc.toString())) {
-				const disposableStore = new DisposableStore();
-				const textModel = this._notebookService.getNotebookTextModel(doc);
-				disposableStore.add(textModel!.onDidModelChangeProxy(e => {
-					this._proxy.$acceptModelChanged(textModel!.uri, e, textModel!.isDirty);
-					this._proxy.$acceptDocumentPropertiesChanged(doc, { selections: { selections: textModel!.selections }, metadata: null });
-				}));
-				disposableStore.add(textModel!.onDidSelectionChange(e => {
-					const selectionsChange = e ? { selections: e } : null;
-					this._proxy.$acceptDocumentPropertiesChanged(doc, { selections: selectionsChange, metadata: null });
-				}));
+		const cellToDto = (cell: NotebookCellTextModel): IMainCellDto => {
+			return {
+				handle: cell.handle,
+				uri: cell.uri,
+				source: cell.textBuffer.getLinesContent(),
+				eol: cell.textBuffer.getEOL(),
+				language: cell.language,
+				cellKind: cell.cellKind,
+				outputs: cell.outputs,
+				metadata: cell.metadata
+			};
+		};

-				this._editorEventListenersMapping.set(textModel!.uri.toString(), disposableStore);
+
+		const notebookDocumentAddedHandler = (textModel: NotebookTextModel) => {
+			if (!this._documentEventListenersMapping.has(textModel.uri)) {
+				const disposableStore = new DisposableStore();
+				disposableStore.add(textModel!.onDidChangeContent(event => {
+					const dto = event.rawEvents.map(e => {
+						const data =
+							e.kind === NotebookCellsChangeType.ModelChange || e.kind === NotebookCellsChangeType.Initialize
+								? {
+									kind: e.kind,
+									versionId: event.versionId,
+									changes: e.changes.map(diff => [diff[0], diff[1], diff[2].map(cell => cellToDto(cell as NotebookCellTextModel))] as [number, number, IMainCellDto[]])
+								}
+								: (
+									e.kind === NotebookCellsChangeType.Move
+										? {
+											kind: e.kind,
+											index: e.index,
+											length: e.length,
+											newIdx: e.newIdx,
+											versionId: event.versionId,
+											cells: e.cells.map(cell => cellToDto(cell as NotebookCellTextModel))
+										}
+										: e
+								);
+
+						return data;
+					});
+
+					/**
+					 * TODO@rebornix, @jrieken
+					 * When a document is modified, it will trigger onDidChangeContent events.
+					 * The first event listener is this one, which doesn't know if the text model is dirty or not. It can ask `workingCopyService` but get the wrong result
+					 * The second event listener is `NotebookEditorModel`, which will then set `isDirty` to `true`.
+					 * Since `e.transient` decides if the model should be dirty or not, we will use the same logic here.
+					 */
+					const hasNonTransientEvent = event.rawEvents.find(e => !e.transient);
+					this._proxy.$acceptModelChanged(textModel.uri, {
+						rawEvents: dto,
+						versionId: event.versionId
+					}, !!hasNonTransientEvent);
+
+					const hasDocumentMetadataChangeEvent = event.rawEvents.find(e => e.kind === NotebookCellsChangeType.ChangeDocumentMetadata);
+					if (!!hasDocumentMetadataChangeEvent) {
+						this._proxy.$acceptDocumentPropertiesChanged(textModel.uri, { metadata: textModel.metadata });
+					}
+				}));
+				this._documentEventListenersMapping.set(textModel!.uri, disposableStore);
 			}
 		};

-		this._register(this._notebookService.onNotebookDocumentAdd((documents) => {
-			documents.forEach(doc => {
-				notebookDocumentAddedHandler(doc);
-			});
+		this._notebookService.listNotebookDocuments().forEach(notebookDocumentAddedHandler);
+		this._register(this._notebookService.onDidAddNotebookDocument(document => {
+			notebookDocumentAddedHandler(document);
 			this._updateState();
 		}));

-		this._notebookService.listNotebookDocuments().forEach((doc) => {
-			notebookDocumentAddedHandler(doc.uri);
-		});
-
-		this._register(this._notebookService.onNotebookDocumentRemove((documents) => {
-			documents.forEach(doc => {
-				this._documentEventListenersMapping.get(doc.toString())?.dispose();
-				this._documentEventListenersMapping.delete(doc.toString());
-			});
-
+		this._register(this._notebookService.onDidRemoveNotebookDocument(uri => {
+			this._documentEventListenersMapping.get(uri)?.dispose();
+			this._documentEventListenersMapping.delete(uri);
 			this._updateState();
 		}));

@@ -404,16 +443,12 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		// }
 	}

-	async $registerNotebookProvider(_extension: NotebookExtensionDescription, _viewType: string, _supportBackup: boolean, options: { transientOutputs: boolean; transientMetadata: TransientMetadata }): Promise<void> {
+	async $registerNotebookProvider(extension: NotebookExtensionDescription, viewType: string, supportBackup: boolean, options: { transientOutputs: boolean; transientMetadata: TransientMetadata }): Promise<void> {
 		const controller: IMainNotebookController = {
-			supportBackup: _supportBackup,
-			options: options,
+			supportBackup,
+			options,
 			reloadNotebook: async (mainthreadTextModel: NotebookTextModel) => {
-				const data = await this._proxy.$resolveNotebookData(_viewType, mainthreadTextModel.uri);
-				if (!data) {
-					return;
-				}
-
+				const data = await this._proxy.$resolveNotebookData(viewType, mainthreadTextModel.uri);
 				mainthreadTextModel.updateLanguages(data.languages);
 				mainthreadTextModel.metadata = data.metadata;
 				mainthreadTextModel.transientOptions = options;
@@ -425,31 +460,17 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 				this._notebookService.transformEditsOutputs(mainthreadTextModel, edits);
 				await new Promise(resolve => {
 					DOM.scheduleAtNextAnimationFrame(() => {
-						const ret = mainthreadTextModel!.applyEdit(mainthreadTextModel!.versionId, edits, true);
+						const ret = mainthreadTextModel!.applyEdits(mainthreadTextModel!.versionId, edits, true, undefined, () => undefined);
 						resolve(ret);
 					});
 				});
 			},
-			createNotebook: async (textModel: NotebookTextModel, backupId?: string) => {
-				// open notebook document
-				const data = await this._proxy.$resolveNotebookData(textModel.viewType, textModel.uri, backupId);
-				if (!data) {
-					return;
-				}
-
-				textModel.updateLanguages(data.languages);
-				textModel.metadata = data.metadata;
-				textModel.transientOptions = options;
-
-				if (data.cells.length) {
-					textModel.initialize(data!.cells);
-				} else {
-					const mainCell = textModel.createCellTextModel('', textModel.resolvedLanguages.length ? textModel.resolvedLanguages[0] : '', CellKind.Code, [], undefined);
-					textModel.insertTemplateCell(mainCell);
-				}
-
-				this._proxy.$acceptDocumentPropertiesChanged(textModel.uri, { selections: null, metadata: textModel.metadata });
-				return;
+			resolveNotebookDocument: async (viewType: string, uri: URI, backupId?: string) => {
+				const data = await this._proxy.$resolveNotebookData(viewType, uri, backupId);
+				return {
+					data,
+					transientOptions: options
+				};
 			},
 			resolveNotebookEditor: async (viewType: string, uri: URI, editorId: string) => {
 				await this._proxy.$resolveNotebookEditor(viewType, uri, editorId);
@@ -457,34 +478,28 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 			onDidReceiveMessage: (editorId: string, rendererType: string | undefined, message: unknown) => {
 				this._proxy.$onDidReceiveMessage(editorId, rendererType, message);
 			},
-			removeNotebookDocument: async (uri: URI) => {
-				return this.removeNotebookTextModel(uri);
-			},
 			save: async (uri: URI, token: CancellationToken) => {
-				return this._proxy.$saveNotebook(_viewType, uri, token);
+				return this._proxy.$saveNotebook(viewType, uri, token);
 			},
 			saveAs: async (uri: URI, target: URI, token: CancellationToken) => {
-				return this._proxy.$saveNotebookAs(_viewType, uri, target, token);
+				return this._proxy.$saveNotebookAs(viewType, uri, target, token);
 			},
 			backup: async (uri: URI, token: CancellationToken) => {
-				return this._proxy.$backup(_viewType, uri, token);
+				return this._proxy.$backup(viewType, uri, token);
 			}
 		};

-		this._notebookProviders.set(_viewType, controller);
-		this._notebookService.registerNotebookController(_viewType, _extension, controller);
+		const disposable = this._notebookService.registerNotebookController(viewType, extension, controller);
+		this._notebookProviders.set(viewType, { controller, disposable });
 		return;
 	}

-	async $onNotebookChange(viewType: string, uri: UriComponents): Promise<void> {
-		const textModel = this._notebookService.getNotebookTextModel(URI.from(uri));
-		textModel?.handleUnknownChange();
-	}
-
 	async $unregisterNotebookProvider(viewType: string): Promise<void> {
-		this._notebookProviders.delete(viewType);
-		this._notebookService.unregisterNotebookProvider(viewType);
-		return;
+		const entry = this._notebookProviders.get(viewType);
+		if (entry) {
+			entry.disposable.dispose();
+			this._notebookProviders.delete(viewType);
+		}
 	}

 	async $registerNotebookKernelProvider(extension: NotebookExtensionDescription, handle: number, documentFilter: INotebookDocumentFilter): Promise<void> {
@@ -547,26 +562,28 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		textModel?.updateLanguages(languages);
 	}

-	async $updateNotebookMetadata(viewType: string, resource: UriComponents, metadata: NotebookDocumentMetadata): Promise<void> {
-		this.logService.debug('MainThreadNotebooks#updateNotebookMetadata', resource.path, metadata);
-		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
-		textModel?.updateNotebookMetadata(metadata);
-	}
-
-	async $updateNotebookCellMetadata(viewType: string, resource: UriComponents, handle: number, metadata: NotebookCellMetadata): Promise<void> {
-		this.logService.debug('MainThreadNotebooks#updateNotebookCellMetadata', resource.path, handle, metadata);
-		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
-		textModel?.changeCellMetadata(handle, metadata, true);
-	}
-
 	async $spliceNotebookCellOutputs(viewType: string, resource: UriComponents, cellHandle: number, splices: NotebookCellOutputsSplice[]): Promise<void> {
 		this.logService.debug('MainThreadNotebooks#spliceNotebookCellOutputs', resource.path, cellHandle);
 		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));

-		if (textModel) {
-			this._notebookService.transformSpliceOutputs(textModel, splices);
-			textModel.spliceNotebookCellOutputs(cellHandle, splices);
+		if (!textModel) {
+			return;
 		}
+
+		this._notebookService.transformSpliceOutputs(textModel, splices);
+		const cell = textModel.cells.find(cell => cell.handle === cellHandle);
+
+		if (!cell) {
+			return;
+		}
+
+		textModel.applyEdits(textModel.versionId, [
+			{
+				editType: CellEditType.OutputsSplice,
+				index: textModel.cells.indexOf(cell),
+				splices
+			}
+		], true, undefined, () => undefined);
 	}

 	async $postMessage(editorId: string, forRendererId: string | undefined, value: any): Promise<boolean> {
@@ -579,21 +596,30 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		return false;
 	}

-	$onDidEdit(resource: UriComponents, viewType: string, editId: number, label: string | undefined): void {
+	$onUndoableContentChange(resource: UriComponents, viewType: string, editId: number, label: string | undefined): void {
 		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));

 		if (textModel) {
-			textModel.handleEdit(label, () => {
-				return this._proxy.$undoNotebook(textModel.viewType, textModel.uri, editId, textModel.isDirty);
+			textModel.handleUnknownUndoableEdit(label, () => {
+				const isDirty = this._workingCopyService.isDirty(textModel.uri.with({ scheme: Schemas.vscodeNotebook }));
+				return this._proxy.$undoNotebook(textModel.viewType, textModel.uri, editId, isDirty);
 			}, () => {
-				return this._proxy.$redoNotebook(textModel.viewType, textModel.uri, editId, textModel.isDirty);
+				const isDirty = this._workingCopyService.isDirty(textModel.uri.with({ scheme: Schemas.vscodeNotebook }));
+				return this._proxy.$redoNotebook(textModel.viewType, textModel.uri, editId, isDirty);
 			});
 		}
 	}

 	$onContentChange(resource: UriComponents, viewType: string): void {
 		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
-		textModel?.handleUnknownChange();
+
+		if (textModel) {
+			textModel.applyEdits(textModel.versionId, [
+				{
+					editType: CellEditType.Unknown
+				}
+			], true, undefined, () => undefined);
+		}
 	}

 	async $tryRevealRange(id: string, range: ICellRange, revealType: NotebookEditorRevealType) {
@@ -640,4 +666,3 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		}
 	}
 }
-