Merge pull request microsoft#184757 from microsoft/aamunger/fileBackedIW

use scratchpad for IW working copy

Author: amunger

extensions/ipynb/package.json

@@ -14,7 +14,8 @@
 		"dropMetadata"
 	],
 	"activationEvents": [
-		"onNotebook:jupyter-notebook"
+		"onNotebook:jupyter-notebook",
+		"onNotebookSerializer:interactive"
 	],
 	"extensionKind": [
 		"workspace",

extensions/ipynb/src/ipynbMain.ts

@@ -43,6 +43,18 @@ export function activate(context: vscode.ExtensionContext) {
 		}
 	} as vscode.NotebookDocumentContentOptions));
 
+	context.subscriptions.push(vscode.workspace.registerNotebookSerializer('interactive', serializer, {
+		transientOutputs: false,
+		transientCellMetadata: {
+			breakpointMargin: true,
+			custom: false,
+			attachments: false
+		},
+		cellContentMetadata: {
+			attachments: true
+		}
+	} as vscode.NotebookDocumentContentOptions));
+
 	vscode.languages.registerCodeLensProvider({ pattern: '**/*.ipynb' }, {
 		provideCodeLenses: (document) => {
 			if (

src/vs/base/common/network.ts

@@ -62,7 +62,6 @@ export namespace Schemas {
 	export const vscodeNotebookCell = 'vscode-notebook-cell';
 	export const vscodeNotebookCellMetadata = 'vscode-notebook-cell-metadata';
 	export const vscodeNotebookCellOutput = 'vscode-notebook-cell-output';
-	export const vscodeInteractive = 'vscode-interactive';
 	export const vscodeInteractiveInput = 'vscode-interactive-input';
 
 	export const vscodeSettings = 'vscode-settings';

src/vs/workbench/api/browser/mainThreadNotebook.ts

@@ -50,8 +50,14 @@ export class MainThreadNotebooks implements MainThreadNotebookShape {
 			options,
 			dataToNotebook: async (data: VSBuffer): Promise<NotebookData> => {
 				const sw = new StopWatch();
-				const dto = await this._proxy.$dataToNotebook(handle, data, CancellationToken.None);
-				const result = NotebookDto.fromNotebookDataDto(dto.value);
+				let result: NotebookData;
+				if (data.byteLength === 0 && viewType === 'interactive') {
+					// we don't want any starting cells for an empty interactive window.
+					result = NotebookDto.fromNotebookDataDto({ cells: [], metadata: {} });
+				} else {
+					const dto = await this._proxy.$dataToNotebook(handle, data, CancellationToken.None);
+					result = NotebookDto.fromNotebookDataDto(dto.value);
+				}
 				this._logService.trace(`[NotebookSerializer] dataToNotebook DONE after ${sw.elapsed()}ms`, {
 					viewType,
 					extensionId: extension.id.value,

src/vs/workbench/contrib/interactive/browser/interactive.contribution.ts

@@ -425,7 +425,7 @@ export class InteractiveEditor extends EditorPane {
 		}
 
 		if (model === null) {
-			throw new Error('?');
+			throw new Error('The Interactive Window model could not be resolved');
 		}
 
 		this.#notebookWidget.value?.setParentContextKeyService(this.#contextKeyService);
@@ -457,7 +457,9 @@ export class InteractiveEditor extends EditorPane {
 			}
 		}));
 
-		const editorModel = await input.resolveInput(this.#notebookWidget.value?.activeKernel?.supportedLanguages[0] ?? PLAINTEXT_LANGUAGE_ID);
+		const languageId = this.#notebookWidget.value?.activeKernel?.supportedLanguages[0] ?? input.language ?? PLAINTEXT_LANGUAGE_ID;
+		const editorModel = await input.resolveInput(languageId);
+		editorModel.setLanguage(languageId);
 		this.#codeEditorWidget.setModel(editorModel);
 		if (viewState?.input) {
 			this.#codeEditorWidget.restoreViewState(viewState.input);
@@ -568,7 +570,6 @@ export class InteractiveEditor extends EditorPane {
 		}
 	}
 
-
 	#syncWithKernel() {
 		const notebook = this.#notebookWidget.value?.textModel;
 		const textModel = this.#codeEditorWidget.getModel();
@@ -581,8 +582,11 @@ export class InteractiveEditor extends EditorPane {
 
 			if (selectedOrSuggested) {
 				const language = selectedOrSuggested.supportedLanguages[0];
-				const newMode = language ? this.#languageService.createById(language).languageId : PLAINTEXT_LANGUAGE_ID;
-				textModel.setLanguage(newMode);
+				// All kernels will initially list plaintext as the supported language before they properly initialized.
+				if (language && language !== 'plaintext') {
+					const newMode = this.#languageService.createById(language).languageId;
+					textModel.setLanguage(newMode);
+				}
 
 				NOTEBOOK_KERNEL.bindTo(this.#contextKeyService).set(selectedOrSuggested.id);
 			}

src/vs/workbench/contrib/interactive/browser/interactiveEditor.ts

@@ -3,26 +3,26 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { VSBuffer } from 'vs/base/common/buffer';
 import { Event } from 'vs/base/common/event';
 import { IReference } from 'vs/base/common/lifecycle';
 import * as paths from 'vs/base/common/path';
-import { isEqual } from 'vs/base/common/resources';
+import { isEqual, joinPath } from 'vs/base/common/resources';
 import { URI } from 'vs/base/common/uri';
+import { PLAINTEXT_LANGUAGE_ID } from 'vs/editor/common/languages/modesRegistry';
 import { IResolvedTextEditorModel, ITextModelService } from 'vs/editor/common/services/resolverService';
+import { IFileDialogService } from 'vs/platform/dialogs/common/dialogs';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IUntypedEditorInput } from 'vs/workbench/common/editor';
+import { EditorInputCapabilities, GroupIdentifier, ISaveOptions, IUntypedEditorInput } from 'vs/workbench/common/editor';
 import { EditorInput } from 'vs/workbench/common/editor/editorInput';
 import { IInteractiveDocumentService } from 'vs/workbench/contrib/interactive/browser/interactiveDocumentService';
 import { IInteractiveHistoryService } from 'vs/workbench/contrib/interactive/browser/interactiveHistoryService';
-import { NotebookCellTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
-import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookTextModel';
-import { CellKind, ICellDto2, IOutputDto, IResolvedNotebookEditorModel, NotebookCellCollapseState, NotebookCellInternalMetadata, NotebookCellMetadata } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+import { IResolvedNotebookEditorModel } from 'vs/workbench/contrib/notebook/common/notebookCommon';
 import { ICompositeNotebookEditorInput, NotebookEditorInput } from 'vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { INotebookService } from 'vs/workbench/contrib/notebook/common/notebookService';
 
 export class InteractiveEditorInput extends EditorInput implements ICompositeNotebookEditorInput {
-	static create(instantiationService: IInstantiationService, resource: URI, inputResource: URI, title?: string) {
-		return instantiationService.createInstance(InteractiveEditorInput, resource, inputResource, title);
+	static create(instantiationService: IInstantiationService, resource: URI, inputResource: URI, title?: string, language?: string) {
+		return instantiationService.createInstance(InteractiveEditorInput, resource, inputResource, title, language);
 	}
 
 	static readonly ID: string = 'workbench.input.interactive';
@@ -37,6 +37,11 @@ export class InteractiveEditorInput extends EditorInput implements ICompositeNot
 
 	private _initTitle?: string;
 
+	get language() {
+		return this._inputModelRef?.object.textEditorModel.getLanguageId() ?? this._initLanguage;
+	}
+	private _initLanguage?: string;
+
 	private _notebookEditorInput: NotebookEditorInput;
 	get notebookEditorInput() {
 		return this._notebookEditorInput;
@@ -74,17 +79,20 @@ export class InteractiveEditorInput extends EditorInput implements ICompositeNot
 		resource: URI,
 		inputResource: URI,
 		title: string | undefined,
+		languageId: string | undefined,
 		@IInstantiationService instantiationService: IInstantiationService,
 		@ITextModelService textModelService: ITextModelService,
-
 		@IInteractiveDocumentService interactiveDocumentService: IInteractiveDocumentService,
-		@IInteractiveHistoryService historyService: IInteractiveHistoryService
+		@IInteractiveHistoryService historyService: IInteractiveHistoryService,
+		@INotebookService private readonly _notebookService: INotebookService,
+		@IFileDialogService private readonly _fileDialogService: IFileDialogService
 	) {
 		const input = NotebookEditorInput.create(instantiationService, resource, 'interactive', {});
 		super();
 		this._notebookEditorInput = input;
 		this._register(this._notebookEditorInput);
 		this._initTitle = title;
+		this._initLanguage = languageId;
 		this._resource = resource;
 		this._inputResource = inputResource;
 		this._inputResolver = null;
@@ -113,8 +121,10 @@ export class InteractiveEditorInput extends EditorInput implements ICompositeNot
 		this._register(this.primary.onDidChangeCapabilities(() => this._onDidChangeCapabilities.fire()));
 	}
 
-	override isDirty() {
-		return false;
+	override get capabilities(): EditorInputCapabilities {
+		return EditorInputCapabilities.Untitled
+			| EditorInputCapabilities.Readonly
+			| EditorInputCapabilities.Scratchpad;
 	}
 
 	private async _resolveEditorModel() {
@@ -134,30 +144,58 @@ export class InteractiveEditorInput extends EditorInput implements ICompositeNot
 			return this._inputResolver;
 		}
 
-		this._inputResolver = this._resolveEditorModel().then(editorModel => {
-			if (this._data) {
-				editorModel?.notebook.reset(this._data.notebookData.cells.map((cell: ISerializedCell) => deserializeCell(cell)), this._data.notebookData.metadata, this._data.notebookData.transientOptions);
-			}
-
-			return editorModel;
-		});
+		this._inputResolver = this._resolveEditorModel();
 
 		return this._inputResolver;
 	}
 
-	async resolveInput(language: string) {
+	async resolveInput(language?: string) {
 		if (this._inputModelRef) {
 			return this._inputModelRef.object.textEditorModel;
 		}
 
-		this._interactiveDocumentService.willCreateInteractiveDocument(this.resource!, this.inputResource, language);
+		const resolvedLanguage = language ?? this._initLanguage ?? PLAINTEXT_LANGUAGE_ID;
+		this._interactiveDocumentService.willCreateInteractiveDocument(this.resource!, this.inputResource, resolvedLanguage);
 		this._inputModelRef = await this._textModelService.createModelReference(this.inputResource);
 
-		if (this._data && this._data.inputData) {
-			this._inputModelRef.object.textEditorModel.setValue(this._data.inputData.value);
+		return this._inputModelRef.object.textEditorModel;
+	}
+
+	override async save(group: GroupIdentifier, options?: ISaveOptions): Promise<EditorInput | IUntypedEditorInput | undefined> {
+		if (this._editorModelReference) {
+
+			if (this.hasCapability(EditorInputCapabilities.Untitled)) {
+				return this.saveAs(group, options);
+			} else {
+				await this._editorModelReference.save(options);
+			}
+
+			return this;
 		}
 
-		return this._inputModelRef.object.textEditorModel;
+		return undefined;
+	}
+
+	override async saveAs(group: GroupIdentifier, options?: ISaveOptions): Promise<IUntypedEditorInput | undefined> {
+		if (!this._editorModelReference) {
+			return undefined;
+		}
+
+		const provider = this._notebookService.getContributedNotebookType('interactive');
+
+		if (!provider) {
+			return undefined;
+		}
+
+		const filename = this.getName() + '.ipynb';
+		const pathCandidate = joinPath(await this._fileDialogService.defaultFilePath(), filename);
+
+		const target = await this._fileDialogService.pickFileToSave(pathCandidate, options?.availableFileSystems);
+		if (!target) {
+			return undefined; // save cancelled
+		}
+
+		return await this._editorModelReference.saveAs(target);
 	}
 
 	override matches(otherInput: EditorInput | IUntypedEditorInput): boolean {
@@ -181,37 +219,6 @@ export class InteractiveEditorInput extends EditorInput implements ICompositeNot
 		return basename.substr(0, basename.length - paths.extname(p).length);
 	}
 
-	getSerialization(): { notebookData: any | undefined; inputData: any | undefined } {
-		return {
-			notebookData: this._serializeNotebook(this._editorModelReference?.notebook),
-			inputData: this._inputModelRef ? {
-				value: this._inputModelRef.object.textEditorModel.getValue(),
-				language: this._inputModelRef.object.textEditorModel.getLanguageId()
-			} : undefined
-		};
-	}
-
-	private _data: { notebookData: any | undefined; inputData: any | undefined } | undefined;
-
-	async restoreSerialization(data: { notebookData: any | undefined; inputData: any | undefined } | undefined) {
-		this._data = data;
-	}
-
-	private _serializeNotebook(notebook?: NotebookTextModel) {
-		if (!notebook) {
-			return undefined;
-		}
-
-		const cells = notebook.cells.map(cell => serializeCell(cell));
-
-		return {
-			cells: cells,
-			metadata: notebook.metadata,
-			transientOptions: notebook.transientOptions
-		};
-	}
-
-
 	override dispose() {
 		// we support closing the interactive window without prompt, so the editor model should not be dirty
 		this._editorModelReference?.revert({ soft: true });
@@ -229,74 +236,3 @@ export class InteractiveEditorInput extends EditorInput implements ICompositeNot
 		return this._historyService;
 	}
 }
-
-/**
- * Serialization of interactive notebook.
- * This is not placed in notebook land as regular notebooks are handled by file service directly.
- */
-
-interface ISerializedOutputItem {
-	readonly mime: string;
-	readonly data: number[];
-}
-
-interface ISerializedCellOutput {
-	outputs: ISerializedOutputItem[];
-	metadata?: Record<string, any>;
-	outputId: string;
-}
-
-export interface ISerializedCell {
-	source: string;
-	language: string;
-	mime: string | undefined;
-	cellKind: CellKind;
-	outputs: ISerializedCellOutput[];
-	metadata?: NotebookCellMetadata;
-	internalMetadata?: NotebookCellInternalMetadata;
-	collapseState?: NotebookCellCollapseState;
-}
-
-function serializeCell(cell: NotebookCellTextModel): ISerializedCell {
-	return {
-		cellKind: cell.cellKind,
-		language: cell.language,
-		metadata: cell.metadata,
-		mime: cell.mime,
-		outputs: cell.outputs.map(output => serializeCellOutput(output)),
-		source: cell.getValue()
-	};
-}
-
-function deserializeCell(cell: ISerializedCell): ICellDto2 {
-	return {
-		cellKind: cell.cellKind,
-		source: cell.source,
-		language: cell.language,
-		metadata: cell.metadata,
-		mime: cell.mime,
-		outputs: cell.outputs.map((output) => deserializeCellOutput(output))
-	};
-}
-
-function serializeCellOutput(output: IOutputDto): ISerializedCellOutput {
-	return {
-		outputId: output.outputId,
-		outputs: output.outputs.map(ot => ({
-			mime: ot.mime,
-			data: ot.data.buffer ? Array.from(ot.data.buffer) : []
-		})),
-		metadata: output.metadata
-	};
-}
-
-function deserializeCellOutput(output: ISerializedCellOutput): IOutputDto {
-	return {
-		outputId: output.outputId,
-		outputs: output.outputs.map(ot => ({
-			mime: ot.mime,
-			data: VSBuffer.fromByteArray(ot.data)
-		})),
-		metadata: output.metadata
-	};
-}