Merge pull request #4449 from microsoft/ulugbekna/interior-catshark

revert last 3 PRs

Author: ulugbekna

src/extension/inlineEdits/common/editRebase.ts

@@ -15,14 +15,6 @@ import { ILinesDiffComputerOptions } from '../../../util/vs/editor/common/diff/l
 const TROUBLESHOOT_EDIT_CONSISTENCY = false;
 
 export interface NesRebaseConfigs {
-	/**
-	 * When enabled, if the user's typed text can be aligned as a subsequence of the
-	 * suggestion's insert text, the rebase absorbs it instead of failing.
-	 * For example, "()" aligns with "(n: number): number" because "(" and ")"
-	 * appear in that order; "(n: )" aligns similarly. Text like "abc" that cannot
-	 * be matched as a subsequence is not absorbed.
-	 */
-	readonly absorbSubsequenceTyping?: boolean;
 }
 
 export class EditDataWithIndex implements IEditData<EditDataWithIndex> {
@@ -239,21 +231,7 @@ function tryRebaseEdits<T extends IEditData<T>>(content: string, ours: Annotated
 export const maxAgreementOffset = 10; // If the user's typing is more than this into the suggestion we consider it a miss.
 export const maxImperfectAgreementLength = 5; // If the user's typing is longer than this and the suggestion is not a perfect match we consider it a miss.
 
-/** Returns true if every character of `typed` appears in `suggestion` in order (subsequence match). */
-function isSubsequenceOf(typed: string, suggestion: string): boolean {
-	let si = 0;
-	for (let ti = 0; ti < typed.length; ti++) {
-		const idx = suggestion.indexOf(typed[ti], si);
-		if (idx === -1) {
-			return false;
-		}
-		si = idx + 1;
-	}
-	return true;
-}
-
 function agreementIndexOf<T extends IEditData<T>>(content: string, ourE: AnnotatedStringReplacement<T>, baseE: StringReplacement, previousBaseE: StringReplacement | undefined, ourNewTextOffset: number, resolution: 'strict' | 'lenient', nesConfigs: NesRebaseConfigs) {
-	const originalBaseNewText = baseE.newText;
 	const minStart = previousBaseE ? previousBaseE.replaceRange.endExclusive : ourE.replaceRange.start;
 	if (minStart < baseE.replaceRange.start) {
 		baseE = new StringReplacement(
@@ -262,20 +240,13 @@ function agreementIndexOf<T extends IEditData<T>>(content: string, ourE: Annotat
 		);
 	}
 	const j = ourE.newText.indexOf(baseE.newText, ourNewTextOffset);
-	const strictRejected = j !== -1 && resolution === 'strict' && (
-		j > maxAgreementOffset ||
-		(j > 0 && baseE.newText.length > maxImperfectAgreementLength)
-	);
-	if (j !== -1 && !strictRejected) {
-		return j + baseE.newText.length;
+	if (resolution === 'strict' && j > maxAgreementOffset) {
+		return -1;
 	}
-	// User typed text not found in suggestion (or rejected by strict limits) — absorb if it aligns as a subsequence.
-	// Guard: only attempt for short typed text to avoid expensive matching on long pastes
-	// and to stay consistent with the existing strict safeguards.
-	if (nesConfigs.absorbSubsequenceTyping && originalBaseNewText.length <= maxImperfectAgreementLength && isSubsequenceOf(originalBaseNewText, ourE.newText.substring(ourNewTextOffset))) {
-		return ourNewTextOffset;
+	if (resolution === 'strict' && j > 0 && baseE.newText.length > maxImperfectAgreementLength) {
+		return -1;
 	}
-	return -1;
+	return j !== -1 ? j + baseE.newText.length : -1;
 }
 
 function computeDiff(original: string, modified: string, offset: number, editData: EditDataWithIndex, options: ILinesDiffComputerOptions): AnnotatedStringReplacement<EditDataWithIndex>[] | undefined {

src/extension/inlineEdits/node/nextEditCache.ts

@@ -15,7 +15,7 @@ import { mapObservableArrayCached } from '../../../util/vs/base/common/observabl
 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, NesRebaseConfigs, tryRebase } from '../common/editRebase';
+import { checkEditConsistency, EditDataWithIndex, tryRebase } from '../common/editRebase';
 import { NextEditFetchRequest } from './nextEditProvider';
 
 export interface CachedEditOpts {
@@ -62,8 +62,8 @@ export class NextEditCache extends Disposable {
 	constructor(
 		public readonly workspace: ObservableWorkspace,
 		private readonly _logService: ILogService,
-		private readonly _configService: IConfigurationService,
-		private readonly _expService: IExperimentationService,
+		configService: IConfigurationService,
+		expService: IExperimentationService,
 	) {
 		super();
 
@@ -81,7 +81,7 @@ export class NextEditCache extends Disposable {
 				}
 				// if editor-change triggering is allowed,
 				// 	it means an edit in file A can result in a cached edit for file B to be less relevant than with the edits in file A included
-				if (this._configService.getExperimentBasedConfig(ConfigKey.Advanced.InlineEditsTriggerOnEditorChangeAfterSeconds, this._expService) !== undefined) {
+				if (configService.getExperimentBasedConfig(ConfigKey.Advanced.InlineEditsTriggerOnEditorChangeAfterSeconds, expService) !== undefined) {
 					for (const [k, v] of this._sharedCache.entries()) {
 						if (v.docId !== doc.id) {
 							this._sharedCache.deleteKey(k);
@@ -112,26 +112,20 @@ export class NextEditCache extends Disposable {
 		docCache.setNoNextEdit(documentContents, editWindow, source);
 	}
 
-	private _getNesRebaseConfigs(): NesRebaseConfigs {
-		return {
-			absorbSubsequenceTyping: this._configService.getExperimentBasedConfig(ConfigKey.TeamInternal.InlineEditsAbsorbSubsequenceTyping, this._expService),
-		};
-	}
-
 	public lookupNextEdit(docId: DocumentId, currentDocumentContents: StringText, currentSelection: readonly OffsetRange[]): CachedOrRebasedEdit | undefined {
 		const docCache = this._documentCaches.get(docId);
 		if (!docCache) {
 			return undefined;
 		}
-		return docCache.lookupNextEdit(currentDocumentContents, currentSelection, this._getNesRebaseConfigs());
+		return docCache.lookupNextEdit(currentDocumentContents, currentSelection);
 	}
 
 	public tryRebaseCacheEntry(cachedEdit: CachedEdit, currentDocumentContents: StringText, currentSelection: readonly OffsetRange[]): CachedOrRebasedEdit | undefined {
 		const docCache = this._documentCaches.get(cachedEdit.docId);
 		if (!docCache) {
 			return undefined;
 		}
-		return docCache.tryRebaseCacheEntry(cachedEdit, currentDocumentContents, currentSelection, this._getNesRebaseConfigs());
+		return docCache.tryRebaseCacheEntry(cachedEdit, currentDocumentContents, currentSelection);
 	}
 
 	public rejectedNextEdit(requestId: string): void {
@@ -234,7 +228,7 @@ class DocumentEditCache {
 		}
 	}
 
-	public lookupNextEdit(currentDocumentContents: StringText, currentSelection: readonly OffsetRange[], nesRebaseConfigs: NesRebaseConfigs): CachedOrRebasedEdit | undefined {
+	public lookupNextEdit(currentDocumentContents: StringText, currentSelection: readonly OffsetRange[]): 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);
@@ -252,15 +246,15 @@ class DocumentEditCache {
 			return cachedEdit;
 		}
 		for (const cachedEdit of this._trackedCachedEdits) {
-			const rebased = this.tryRebaseCacheEntry(cachedEdit, currentDocumentContents, currentSelection, nesRebaseConfigs);
+			const rebased = this.tryRebaseCacheEntry(cachedEdit, currentDocumentContents, currentSelection);
 			if (rebased) {
 				return rebased;
 			}
 		}
 		return undefined;
 	}
 
-	public tryRebaseCacheEntry(cachedEdit: CachedEdit, currentDocumentContents: StringText, currentSelection: readonly OffsetRange[], nesRebaseConfigs: NesRebaseConfigs): CachedEdit | undefined {
+	public tryRebaseCacheEntry(cachedEdit: CachedEdit, currentDocumentContents: StringText, currentSelection: readonly OffsetRange[]): CachedEdit | undefined {
 		const logger = this._logger.createSubLogger('tryRebaseCacheEntry');
 		if (cachedEdit.userEditSince && !cachedEdit.rebaseFailed) {
 			const originalEdits = cachedEdit.edits || (cachedEdit.edit ? [cachedEdit.edit] : []);
@@ -273,7 +267,7 @@ class DocumentEditCache {
 				: [cachedEdit.editWindow];
 
 			for (const window of windowsToTry) {
-				const res = tryRebase(cachedEdit.documentBeforeEdit.value, window, originalEdits, cachedEdit.detailedEdits, cachedEdit.userEditSince, currentDocumentContents.value, currentSelection, 'strict', logger, nesRebaseConfigs);
+				const res = tryRebase(cachedEdit.documentBeforeEdit.value, window, originalEdits, cachedEdit.detailedEdits, cachedEdit.userEditSince, currentDocumentContents.value, currentSelection, 'strict', logger);
 				if (res === 'rebaseFailed') {
 					cachedEdit.rebaseFailed = true;
 					return undefined;