@vscode/chat-lib 0.0.1

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

@@ -0,0 +1,164 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,205 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,278 @@
+/*---------------------------------------------------------------------------------------------
+ *  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]);
+	}
+}