@vscode/chat-lib 0.0.1 → 0.0.3

package/src/_internal/extension/inlineEdits/common/rejectionCollector.ts

@@ -1,164 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { DocumentId } from '../../../platform/inlineEdits/common/dataTypes/documentId';
-import { IObservableDocument, ObservableWorkspace } from '../../../platform/inlineEdits/common/observableWorkspace';
-import { autorunWithChanges } from '../../../platform/inlineEdits/common/utils/observable';
-import { createTracer, ITracer } from '../../../util/common/tracing';
-import { Disposable, IDisposable, toDisposable } from '../../../util/vs/base/common/lifecycle';
-import { mapObservableArrayCached } from '../../../util/vs/base/common/observable';
-import { StringEdit, StringReplacement } from '../../../util/vs/editor/common/core/edits/stringEdit';
-import { StringText } from '../../../util/vs/editor/common/core/text/abstractText';
-
-export class RejectionCollector extends Disposable {
-	private readonly _garbageCollector = this._register(new LRUGarbageCollector(20));
-	private readonly _documentCaches = new Map<DocumentId, DocumentRejectionTracker>();
-	private readonly _tracer: ITracer;
-
-	constructor(
-		public readonly workspace: ObservableWorkspace,
-		trace: (s: string) => void,
-	) {
-		super();
-
-		this._tracer = createTracer(['NES', 'RejectionCollector'], trace);
-
-		mapObservableArrayCached(this, workspace.openDocuments, (doc, store) => {
-			const state = new DocumentRejectionTracker(doc, this._garbageCollector, this._tracer);
-			this._documentCaches.set(state.doc.id, state);
-
-			store.add(autorunWithChanges(this, {
-				value: doc.value,
-				selection: doc.selection,
-				languageId: doc.languageId,
-			}, (data) => {
-				for (const edit of data.value.changes) {
-					state.handleEdit(edit, data.value.value);
-				}
-			}));
-
-			store.add(toDisposable(() => {
-				this._documentCaches.delete(doc.id);
-			}));
-		}).recomputeInitiallyAndOnChange(this._store);
-	}
-
-	public reject(docId: DocumentId, edit: StringReplacement): void {
-		const docCache = this._documentCaches.get(docId);
-		if (!docCache) {
-			this._tracer.trace(`Rejecting, no document cache: ${edit}`);
-			return;
-		}
-		const e = edit.removeCommonSuffixAndPrefix(docCache.doc.value.get().value);
-		this._tracer.trace(`Rejecting: ${e}`);
-		docCache.reject(e);
-	}
-
-	public isRejected(docId: DocumentId, edit: StringReplacement): boolean {
-		const docCache = this._documentCaches.get(docId);
-		if (!docCache) {
-			this._tracer.trace(`Checking rejection, no document cache: ${edit}`);
-			return false;
-		}
-		const e = edit.removeCommonSuffixAndPrefix(docCache.doc.value.get().value);
-		const isRejected = docCache.isRejected(e);
-		this._tracer.trace(`Checking rejection, ${isRejected ? 'rejected' : 'not rejected'}: ${e}`);
-		return isRejected;
-	}
-
-	public clear() {
-		this._garbageCollector.clear();
-	}
-}
-
-class DocumentRejectionTracker {
-	private readonly _rejectedEdits = new Set<RejectedEdit>();
-
-	constructor(
-		public readonly doc: IObservableDocument,
-		private readonly _garbageCollector: LRUGarbageCollector,
-		private readonly _tracer: ITracer,
-	) {
-	}
-
-	public handleEdit(edit: StringEdit, currentContent: StringText): void {
-		for (const r of [...this._rejectedEdits]) {
-			r.handleEdit(edit, currentContent); // this can remove the rejected edit from the set
-		}
-	}
-
-	public reject(edit: StringReplacement): void {
-		if (this.isRejected(edit)) {
-			// already tracked
-			return;
-		}
-		const r = new RejectedEdit(edit.toEdit(), () => {
-			this._tracer.trace(`Evicting: ${edit}`);
-			this._rejectedEdits.delete(r);
-		});
-		this._rejectedEdits.add(r);
-		this._garbageCollector.put(r);
-	}
-
-	public isRejected(edit: StringReplacement): boolean {
-		for (const r of this._rejectedEdits) {
-			if (r.isRejected(edit)) {
-				return true;
-			}
-		}
-		return false;
-	}
-}
-
-class RejectedEdit implements IDisposable {
-	constructor(
-		private _edit: StringEdit,
-		private readonly _onDispose: () => void,
-	) { }
-
-	public handleEdit(edit: StringEdit, currentContent: StringText): void {
-		const d = this._edit.tryRebase(edit);
-		if (d) {
-			this._edit = d.removeCommonSuffixAndPrefix(currentContent.value);
-		} else {
-			this.dispose();
-		}
-	}
-
-	public isRejected(edit: StringReplacement): boolean {
-		return this._edit.equals(edit.toEdit());
-	}
-
-	public dispose(): void {
-		this._onDispose();
-	}
-}
-
-class LRUGarbageCollector implements IDisposable {
-	private _disposables: IDisposable[] = [];
-
-	constructor(
-		private _maxSize: number,
-	) {
-	}
-
-	put(disposable: IDisposable): void {
-		this._disposables.push(disposable);
-		if (this._disposables.length > this._maxSize) {
-			this._disposables.shift()!.dispose();
-		}
-	}
-
-	public clear(): void {
-		for (const d of this._disposables) {
-			d.dispose();
-		}
-		this._disposables = [];
-	}
-
-	public dispose(): void {
-		this.clear();
-	}
-}

package/src/_internal/extension/inlineEdits/node/debugRecorder.ts

@@ -1,205 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { DocumentId } from '../../../platform/inlineEdits/common/dataTypes/documentId';
-import { serializeStringEdit } from '../../../platform/inlineEdits/common/dataTypes/editUtils';
-import { LanguageId } from '../../../platform/inlineEdits/common/dataTypes/languageId';
-import { DebugRecorderBookmark } from '../../../platform/inlineEdits/common/debugRecorderBookmark';
-import { ObservableWorkspace } from '../../../platform/inlineEdits/common/observableWorkspace';
-import { autorunWithChanges } from '../../../platform/inlineEdits/common/utils/observable';
-import { Instant, now } from '../../../platform/inlineEdits/common/utils/utils';
-import { ISerializedOffsetRange, LogEntry } from '../../../platform/workspaceRecorder/common/workspaceLog';
-import { compareBy, numberComparator } from '../../../util/vs/base/common/arrays';
-import { Disposable, toDisposable } from '../../../util/vs/base/common/lifecycle';
-import { Schemas } from '../../../util/vs/base/common/network';
-import { mapObservableArrayCached } from '../../../util/vs/base/common/observableInternal';
-import { relative } from '../../../util/vs/base/common/path';
-import { URI } from '../../../util/vs/base/common/uri';
-import { generateUuid } from '../../../util/vs/base/common/uuid';
-import { StringEdit } from '../../../util/vs/editor/common/core/edits/stringEdit';
-import { OffsetRange } from '../../../util/vs/editor/common/core/ranges/offsetRange';
-import { StringText } from '../../../util/vs/editor/common/core/text/abstractText';
-
-export class DebugRecorder extends Disposable {
-	private _id: number = 0;
-	private readonly _documentHistories = new Map<DocumentId, DocumentHistory>();
-
-	private _workspaceRoot: URI | undefined;
-
-	constructor(
-		private readonly _workspace: ObservableWorkspace,
-		private readonly getNow = now
-	) {
-		super();
-
-		mapObservableArrayCached(this, this._workspace.openDocuments, (doc, store) => {
-			const root = this._workspace.getWorkspaceRoot(doc.id);
-			if (!root) {
-				return;
-			}
-			if (!this._workspaceRoot) {
-				this._workspaceRoot = root;
-			} else {
-				if (this._workspaceRoot.toString() !== root.toString()) {
-					// document is from a different root -> ignore
-					return;
-				}
-			}
-
-			const state = new DocumentHistory(root, doc.id, doc.value.get().value, this._id++, doc.languageId.get(), () => this.getTimestamp());
-			this._documentHistories.set(state.docId, state);
-
-			store.add(autorunWithChanges(this, {
-				value: doc.value,
-				selection: doc.selection,
-				languageId: doc.languageId,
-			}, (data) => {
-				if (data.languageId.changes.length > 0) {
-					state.languageId = data.languageId.value;
-				}
-				for (const edit of data.value.changes) {
-					state.handleEdit(edit);
-				}
-				if (data.selection.changes.length > 0) {
-					state.handleSelections(data.selection.value);
-				}
-			}));
-
-			store.add(toDisposable(() => {
-				// We might want to soft-delete the document
-				this._documentHistories.delete(doc.id);
-			}));
-		}, d => d.id).recomputeInitiallyAndOnChange(this._store);
-	}
-
-	private _lastTimestamp: number | undefined;
-	public getTimestamp(): number {
-		let newTimestamp = this.getNow();
-		if (this._lastTimestamp !== undefined && newTimestamp <= this._lastTimestamp) { // we want total ordering on the events
-			newTimestamp = this._lastTimestamp + 1;
-		}
-		this._lastTimestamp = newTimestamp;
-		return newTimestamp;
-	}
-
-	public getRecentLog(bookmark: DebugRecorderBookmark | undefined = undefined): LogEntry[] | undefined {
-		if (!this._workspaceRoot) { // possible if the open file doesn't belong to a workspace
-			return undefined;
-		}
-
-		const log: {
-			entry: LogEntry;
-			sortTime: number;
-		}[] = [];
-
-		log.push({ entry: { documentType: 'workspaceRecording@1.0', kind: 'header', repoRootUri: this._workspaceRoot.toString(), time: this.getNow(), uuid: generateUuid() }, sortTime: 0 });
-
-		for (const doc of this._documentHistories.values()) {
-			log.push(...doc.getDocumentLog(bookmark));
-		}
-
-		log.sort(compareBy(e => e.sortTime, numberComparator));
-
-		return log.map(l => l.entry);
-	}
-
-	public createBookmark(): DebugRecorderBookmark {
-		return new DebugRecorderBookmark(this.getNow());
-	}
-}
-
-class DocumentHistory {
-	private _baseValue: StringText;
-	/**
-	 * Stores edits and selection changes in the order they happened.
-	 */
-	private _edits: ({
-		kind: 'edit';
-		edit: StringEdit;
-		instant: Instant;
-	} | {
-		kind: 'selections';
-		selections: readonly OffsetRange[];
-		instant: Instant;
-	})[] = [];
-
-	public readonly creationTime: number;
-	private _baseValueTime: number;
-
-	constructor(
-		public readonly workspaceUri: URI,
-		public readonly docId: DocumentId,
-		initialValue: string,
-		public readonly id: number,
-		public languageId: LanguageId,
-		private readonly getNow: () => Instant
-	) {
-		this._baseValue = new StringText(initialValue);
-		this.creationTime = this.getNow();
-		this._baseValueTime = this.creationTime;
-	}
-
-	public handleSelections(selections: readonly OffsetRange[]): void {
-		this._edits.push({ kind: 'selections', selections, instant: this.getNow() });
-	}
-
-	public handleEdit(edit: StringEdit): void {
-		if (edit.isEmpty()) {
-			return;
-		}
-
-		this._edits.push({ kind: 'edit', edit, instant: this.getNow() });
-
-		this.cleanUpHistory();
-	}
-
-	public cleanUpHistory(): void {
-		const minuteMs = 60 * 1000;
-		const earliestTime = this.getNow() - 10 * minuteMs;
-		while (this._edits.length > 0 && this._edits[0].instant < earliestTime) {
-			const edit = this._edits.shift()!;
-			if (edit.kind === 'selections') {
-				continue; // we drop selection changes
-			}
-			this._baseValue = edit.edit.applyOnText(this._baseValue);
-			this._baseValueTime = edit.instant;
-		}
-	}
-
-	private readonly relativePath = (() => {
-		const basePath = relative(this.workspaceUri.path, this.docId.path);
-		return this.docId.toUri().scheme === Schemas.vscodeNotebookCell ? `${basePath}#${this.docId.fragment}` : basePath;
-	})();
-
-	getDocumentLog(bookmark: DebugRecorderBookmark | undefined): { entry: LogEntry; sortTime: number }[] {
-		this.cleanUpHistory();
-
-		if (this._edits.length === 0) {
-			return [];
-		}
-
-		const log: { entry: LogEntry; sortTime: number }[] = [];
-		log.push({ entry: { kind: 'documentEncountered', id: this.id, relativePath: this.relativePath, time: this.creationTime }, sortTime: this.creationTime });
-		let docVersion = 1;
-		log.push({ entry: { kind: 'setContent', id: this.id, v: docVersion, content: this._baseValue.value, time: this._baseValueTime }, sortTime: this._baseValueTime });
-		log.push({ entry: { kind: 'opened', id: this.id, time: this._baseValueTime }, sortTime: this._baseValueTime });
-
-		for (const editOrSelectionChange of this._edits) {
-			if (bookmark && editOrSelectionChange.instant > bookmark.timeMs) {
-				// only considers edits that happened before the bookmark
-				break;
-			}
-			docVersion++;
-			if (editOrSelectionChange.kind === 'selections') {
-				const serializedOffsetRange: ISerializedOffsetRange[] = editOrSelectionChange.selections.map(s => [s.start, s.endExclusive]);
-				log.push({ entry: { kind: 'selectionChanged', id: this.id, selection: serializedOffsetRange, time: editOrSelectionChange.instant }, sortTime: editOrSelectionChange.instant });
-			} else {
-				log.push({ entry: { kind: 'changed', id: this.id, v: docVersion, edit: serializeStringEdit(editOrSelectionChange.edit), time: editOrSelectionChange.instant }, sortTime: editOrSelectionChange.instant });
-			}
-		}
-
-		return log;
-	}
-}

package/src/_internal/extension/inlineEdits/node/importFiltering.ts

@@ -1,25 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { StatelessNextEditDocument } from '../../../platform/inlineEdits/common/statelessNextEditProvider';
-import { coalesce } from '../../../util/vs/base/common/arrays';
-import { LineReplacement } from '../../../util/vs/editor/common/core/edits/lineEdit';
-import { isImportStatement } from '../../prompt/common/importStatement';
-
-export class IgnoreImportChangesAspect {
-	public static isImportChange(edit: LineReplacement, languageId: string, lines: string[]): boolean {
-		return edit.newLines.some(l => isImportStatement(l, languageId)) || getOldLines(edit, lines).some(l => isImportStatement(l, languageId));
-	}
-
-	public static filterEdit(resultDocument: StatelessNextEditDocument, singleEdits: readonly LineReplacement[]): readonly LineReplacement[] {
-		const languageId = resultDocument.languageId;
-		const filteredEdits = singleEdits.filter(e => !IgnoreImportChangesAspect.isImportChange(e, languageId, resultDocument.documentLinesBeforeEdit));
-		return filteredEdits;
-	}
-}
-
-function getOldLines(edit: LineReplacement, lines: string[]): string[] {
-	return coalesce(edit.lineRange.mapToLineArray<string | undefined>(l => lines[l - 1]));
-}

package/src/_internal/extension/inlineEdits/node/nesConfigs.ts

@@ -1,12 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export interface INesConfigs {
-	isAsyncCompletions: boolean;
-	isRevisedCacheStrategy: boolean;
-	isCacheTracksRejections: boolean;
-	isRecentlyShownCacheEnabled: boolean;
-	debounceUseCoreRequestTime: boolean;
-}

package/src/_internal/extension/inlineEdits/node/nextEditCache.ts

@@ -1,278 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { DocumentId } from '../../../platform/inlineEdits/common/dataTypes/documentId';
-import { IObservableDocument, ObservableWorkspace } from '../../../platform/inlineEdits/common/observableWorkspace';
-import { autorunWithChanges } from '../../../platform/inlineEdits/common/utils/observable';
-import { ILogService } from '../../../platform/log/common/logService';
-import { LRUCache } from '../../../util/common/cache';
-import { createTracer, ITracer } from '../../../util/common/tracing';
-import { Disposable, toDisposable } from '../../../util/vs/base/common/lifecycle';
-import { mapObservableArrayCached } from '../../../util/vs/base/common/observableInternal';
-import { AnnotatedStringReplacement, StringEdit, StringReplacement } from '../../../util/vs/editor/common/core/edits/stringEdit';
-import { OffsetRange } from '../../../util/vs/editor/common/core/ranges/offsetRange';
-import { StringText } from '../../../util/vs/editor/common/core/text/abstractText';
-import { checkEditConsistency, EditDataWithIndex, tryRebase } from '../common/editRebase';
-import { INesConfigs } from './nesConfigs';
-import { NextEditFetchRequest } from './nextEditProvider';
-
-export interface CachedEdit {
-	docId: DocumentId;
-	documentBeforeEdit: StringText;
-	editWindow?: OffsetRange;
-	edit?: StringReplacement;
-	edits?: StringReplacement[];
-	detailedEdits: AnnotatedStringReplacement<EditDataWithIndex>[][];
-	userEditSince?: StringEdit;
-	rebaseFailed?: boolean;
-	rejected?: boolean;
-
-	/**
-	 * When caching multiple edits, this is the order in which they were applied.
-	 */
-	subsequentN?: number;
-	source: NextEditFetchRequest;
-	cacheTime: number;
-}
-
-export type CachedOrRebasedEdit = CachedEdit & { rebasedEdit?: StringReplacement; rebasedEditIndex?: number };
-
-export class NextEditCache extends Disposable {
-	private readonly _documentCaches = new Map<DocumentId, DocumentEditCache>();
-	private readonly _sharedCache = new LRUCache<CachedEdit>(50);
-
-	constructor(
-		public readonly workspace: ObservableWorkspace,
-		private readonly _logService: ILogService,
-	) {
-		super();
-
-		mapObservableArrayCached(this, workspace.openDocuments, (doc, store) => {
-			const state = new DocumentEditCache(this, doc.id, doc, this._sharedCache, this._logService);
-			this._documentCaches.set(state.docId, state);
-
-			store.add(autorunWithChanges(this, {
-				value: doc.value,
-			}, (data) => {
-				for (const edit of data.value.changes) {
-					if (!edit.isEmpty()) {
-						state.handleEdit(edit);
-					}
-				}
-			}));
-
-			store.add(toDisposable(() => {
-				this._documentCaches.delete(doc.id);
-			}));
-		}).recomputeInitiallyAndOnChange(this._store);
-	}
-
-	public setKthNextEdit(docId: DocumentId, documentContents: StringText, editWindow: OffsetRange | undefined, nextEdit: StringReplacement, subsequentN: number, nextEdits: StringReplacement[] | undefined, userEditSince: StringEdit | undefined, source: NextEditFetchRequest): CachedEdit | undefined {
-		const docCache = this._documentCaches.get(docId);
-		if (!docCache) {
-			return;
-		}
-		return docCache.setKthNextEdit(documentContents, editWindow, nextEdit, nextEdits, userEditSince, subsequentN, source);
-	}
-
-	public setNoNextEdit(docId: DocumentId, documentContents: StringText, editWindow: OffsetRange | undefined, source: NextEditFetchRequest, nesConfigs: INesConfigs) {
-		const docCache = this._documentCaches.get(docId);
-		if (!docCache) {
-			return;
-		}
-		docCache.setNoNextEdit(documentContents, editWindow, source, nesConfigs);
-	}
-
-	public lookupNextEdit(docId: DocumentId, currentDocumentContents: StringText, currentSelection: readonly OffsetRange[], nesConfigs: INesConfigs): CachedOrRebasedEdit | undefined {
-		const docCache = this._documentCaches.get(docId);
-		if (!docCache) {
-			return undefined;
-		}
-		return docCache.lookupNextEdit(currentDocumentContents, currentSelection, nesConfigs);
-	}
-
-	public tryRebaseCacheEntry(cachedEdit: CachedEdit, currentDocumentContents: StringText, currentSelection: readonly OffsetRange[], nesConfigs: INesConfigs): CachedOrRebasedEdit | undefined {
-		const docCache = this._documentCaches.get(cachedEdit.docId);
-		if (!docCache) {
-			return undefined;
-		}
-		return docCache.tryRebaseCacheEntry(cachedEdit, currentDocumentContents, currentSelection, nesConfigs);
-	}
-
-	public rejectedNextEdit(requestId: string): void {
-		this._sharedCache.getValues()
-			.filter(v => v.source.headerRequestId === requestId)
-			.forEach(v => v.rejected = true);
-	}
-
-	public isRejectedNextEdit(docId: DocumentId, currentDocumentContents: StringText, edit: StringReplacement, nesConfigs: INesConfigs) {
-		const docCache = this._documentCaches.get(docId);
-		if (!docCache) {
-			return false;
-		}
-		return docCache.isRejectedNextEdit(currentDocumentContents, edit, nesConfigs);
-	}
-
-	public evictedCachedEdit(cachedEdit: CachedEdit) {
-		const docCache = this._documentCaches.get(cachedEdit.docId);
-		if (docCache) {
-			docCache.evictedCachedEdit(cachedEdit);
-		}
-	}
-
-	public clear() {
-		this._documentCaches.forEach(cache => cache.clear());
-		this._sharedCache.clear();
-	}
-}
-
-class DocumentEditCache {
-
-	private readonly _trackedCachedEdits: CachedEdit[] = [];
-	private _tracer: ITracer;
-
-	constructor(
-		private readonly _nextEditCache: NextEditCache,
-		public readonly docId: DocumentId,
-		private readonly _doc: IObservableDocument,
-		private readonly _sharedCache: LRUCache<CachedEdit>,
-		private readonly _logService: ILogService,
-	) {
-		this._tracer = createTracer(['NES', 'DocumentEditCache'], (s) => this._logService.trace(s));
-	}
-
-	public handleEdit(edit: StringEdit): void {
-		const tracer = this._tracer.sub('handleEdit');
-		for (const cachedEdit of this._trackedCachedEdits) {
-			if (cachedEdit.userEditSince) {
-				cachedEdit.userEditSince = cachedEdit.userEditSince.compose(edit);
-				cachedEdit.rebaseFailed = false;
-				if (!checkEditConsistency(cachedEdit.documentBeforeEdit.value, cachedEdit.userEditSince, this._doc.value.get().value, tracer)) {
-					cachedEdit.userEditSince = undefined;
-				}
-			}
-		}
-	}
-
-	public evictedCachedEdit(cachedEdit: CachedEdit) {
-		const index = this._trackedCachedEdits.indexOf(cachedEdit);
-		if (index !== -1) {
-			this._trackedCachedEdits.splice(index, 1);
-		}
-	}
-
-	public clear() {
-		this._trackedCachedEdits.length = 0;
-	}
-
-	public setKthNextEdit(documentContents: StringText, editWindow: OffsetRange | undefined, nextEdit: StringReplacement, nextEdits: StringReplacement[] | undefined, userEditSince: StringEdit | undefined, subsequentN: number, source: NextEditFetchRequest): CachedEdit {
-		const key = this._getKey(documentContents.value);
-		const cachedEdit: CachedEdit = { docId: this.docId, edit: nextEdit, edits: nextEdits, detailedEdits: [], userEditSince, subsequentN, source, documentBeforeEdit: documentContents, editWindow, cacheTime: Date.now() };
-		if (userEditSince) {
-			if (!checkEditConsistency(cachedEdit.documentBeforeEdit.value, userEditSince, this._doc.value.get().value, this._tracer.sub('setKthNextEdit'))) {
-				cachedEdit.userEditSince = undefined;
-			} else {
-				this._trackedCachedEdits.unshift(cachedEdit);
-			}
-		}
-		const existing = this._sharedCache.get(key);
-		if (existing) {
-			this.evictedCachedEdit(existing);
-		}
-		const evicted = this._sharedCache.put(key, cachedEdit);
-		if (evicted) {
-			this._nextEditCache.evictedCachedEdit(evicted[1]);
-		}
-		return cachedEdit;
-	}
-
-	public setNoNextEdit(documentContents: StringText, editWindow: OffsetRange | undefined, source: NextEditFetchRequest, nesConfigs: INesConfigs) {
-		const key = this._getKey(documentContents.value);
-		const cachedEdit: CachedEdit = { docId: this.docId, edits: [], detailedEdits: [], source, documentBeforeEdit: documentContents, editWindow, cacheTime: Date.now() };
-		const existing = this._sharedCache.get(key);
-		if (existing) {
-			this.evictedCachedEdit(existing);
-		}
-		const evicted = this._sharedCache.put(key, cachedEdit);
-		if (evicted) {
-			this._nextEditCache.evictedCachedEdit(evicted[1]);
-		}
-	}
-
-	public lookupNextEdit(currentDocumentContents: StringText, currentSelection: readonly OffsetRange[], nesConfigs: INesConfigs): CachedOrRebasedEdit | undefined {
-		// TODO@chrmarti: Update entries i > 1 with user edits and edit window and start tracking.
-		const key = this._getKey(currentDocumentContents.value);
-		const cachedEdit = this._sharedCache.get(key);
-		if (cachedEdit) {
-			const editWindow = cachedEdit.editWindow;
-			const cursorRange = currentSelection[0];
-			if (editWindow && cursorRange && !editWindow.containsRange(cursorRange)) {
-				return undefined;
-			}
-			return cachedEdit;
-		}
-		if (!nesConfigs.isRevisedCacheStrategy) {
-			return undefined;
-		}
-		for (const cachedEdit of this._trackedCachedEdits) {
-			const rebased = this.tryRebaseCacheEntry(cachedEdit, currentDocumentContents, currentSelection, nesConfigs);
-			if (rebased) {
-				return rebased;
-			}
-		}
-		return undefined;
-	}
-
-	public tryRebaseCacheEntry(cachedEdit: CachedEdit, currentDocumentContents: StringText, currentSelection: readonly OffsetRange[], nesConfigs: INesConfigs) {
-		const tracer = this._tracer.sub('tryRebaseCacheEntry');
-		if (cachedEdit.userEditSince && !cachedEdit.rebaseFailed) {
-			const originalEdits = cachedEdit.edits || (cachedEdit.edit ? [cachedEdit.edit] : []);
-			const res = tryRebase(cachedEdit.documentBeforeEdit.value, cachedEdit.editWindow, originalEdits, cachedEdit.detailedEdits, cachedEdit.userEditSince, currentDocumentContents.value, currentSelection, 'strict', tracer, nesConfigs);
-			if (res === 'rebaseFailed') {
-				cachedEdit.rebaseFailed = true;
-			} else if (res === 'inconsistentEdits' || res === 'error') {
-				cachedEdit.userEditSince = undefined;
-			} else if (res === 'outsideEditWindow') {
-				// miss
-			} else if (res.length) {
-				if (!cachedEdit.rejected && this.isRejectedNextEdit(currentDocumentContents, res[0].rebasedEdit, nesConfigs)) {
-					cachedEdit.rejected = true;
-				}
-				return { ...cachedEdit, ...res[0] };
-			} else if (!originalEdits.length) {
-				return cachedEdit; // cached 'no edits'
-			}
-		}
-		return undefined;
-	}
-
-	public isRejectedNextEdit(currentDocumentContents: StringText, edit: StringReplacement, nesConfigs: INesConfigs) {
-		const tracer = this._tracer.sub('isRejectedNextEdit');
-		const resultEdit = edit.removeCommonSuffixAndPrefix(currentDocumentContents.value);
-		for (const rejectedEdit of this._trackedCachedEdits.filter(edit => edit.rejected)) {
-			if (!rejectedEdit.userEditSince) {
-				continue;
-			}
-			const edits = rejectedEdit.edits || (rejectedEdit.edit ? [rejectedEdit.edit] : []);
-			if (!edits.length) {
-				continue; // cached 'no edits'
-			}
-			const rejectedEdits = tryRebase(rejectedEdit.documentBeforeEdit.value, undefined, edits, rejectedEdit.detailedEdits, rejectedEdit.userEditSince, currentDocumentContents.value, [], 'lenient', tracer, nesConfigs);
-			if (typeof rejectedEdits === 'string') {
-				continue;
-			}
-			const rejected = rejectedEdits.some(rejected => rejected.rebasedEdit.removeCommonSuffixAndPrefix(currentDocumentContents.value).equals(resultEdit));
-			if (rejected) {
-				tracer.trace('Found rejected edit that matches current edit');
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private _getKey(val: string): string {
-		return JSON.stringify([this.docId.uri, val]);
-	}
-}