@codingame/monaco-vscode-api 15.0.3 → 16.0.1

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineCompletionsModel.js

@@ -3,6 +3,7 @@ import { __decorate, __param } from '../../../../../../../../external/tslib/tsli
 import { mapFindFirst } from '../../../../../base/common/arraysFind.js';
 import { itemsEquals } from '../../../../../base/common/equals.js';
 import { BugIndicatingError, onUnexpectedExternalError, onUnexpectedError } from '../../../../../base/common/errors.js';
+import { Emitter } from '../../../../../base/common/event.js';
 import { Disposable } from '../../../../../base/common/lifecycle.js';
 import '../../../../../base/common/observableInternal/index.js';
 import { firstNonWhitespaceIndex, commonPrefixLength } from '../../../../../base/common/strings.js';
@@ -61,12 +62,35 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         this._selectedInlineCompletionId = observableValue(this, undefined);
         this.primaryPosition = derived(this, reader => this._positions.read(reader)[0] ?? ( new Position(1, 1)));
         this._isAcceptingPartially = false;
+        this._onDidAccept = ( new Emitter());
+        this.onDidAccept = this._onDidAccept.event;
         this._editorObs = observableCodeEditor(this._editor);
         this._suggestPreviewEnabled = ( this._editorObs.getOption(EditorOption.suggest).map(v => v.preview));
         this._suggestPreviewMode = ( this._editorObs.getOption(EditorOption.suggest).map(v => v.previewMode));
         this._inlineSuggestMode = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(v => v.mode));
         this._inlineEditsEnabled = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(v => !!v.edits.enabled));
-        this._inlineEditsShowCollapsed = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.showCollapsed));
+        this._inlineEditsShowCollapsedEnabled = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.showCollapsed));
+        this._lastShownInlineCompletionInfo = undefined;
+        this._lastAcceptedInlineCompletionInfo = undefined;
+        this._didUndoInlineEdits = derivedHandleChanges({
+            owner: this,
+            createEmptyChangeSummary: () => ({ didUndo: false }),
+            handleChange: (ctx, changeSummary) => {
+                changeSummary.didUndo = ctx.didChange(this._textModelVersionId) && !!ctx.change?.isUndoing;
+                return true;
+            }
+        }, (reader, changeSummary) => {
+            const versionId = this._textModelVersionId.read(reader);
+            if (versionId !== null
+                && this._lastAcceptedInlineCompletionInfo
+                && this._lastAcceptedInlineCompletionInfo.textModelVersionIdAfter === versionId - 1
+                && this._lastAcceptedInlineCompletionInfo.inlineCompletion.isInlineEdit
+                && changeSummary.didUndo) {
+                this._lastAcceptedInlineCompletionInfo = undefined;
+                return true;
+            }
+            return false;
+        });
         this._preserveCurrentCompletionReasons = ( new Set([
             VersionIdChangeReason.Redo,
             VersionIdChangeReason.Undo,
@@ -101,6 +125,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 return true;
             },
         }, (reader, changeSummary) => {
+            this._source.clearOperationOnTextModelChange.read(reader);
             this._noDelaySignal.read(reader);
             this.dontRefetchSignal.read(reader);
             this._onlyRequestInlineEditsSignal.read(reader);
@@ -126,16 +151,34 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (changeSummary.dontRefetch) {
                 return Promise.resolve(true);
             }
-            const context = {
+            if (this._didUndoInlineEdits.read(reader)) {
+                transaction(tx => {
+                    this._source.clear(tx);
+                });
+                return undefined;
+            }
+            let context = {
                 triggerKind: changeSummary.inlineCompletionTriggerKind,
                 selectedSuggestionInfo: suggestItem?.toSelectedSuggestionInfo(),
                 includeInlineCompletions: !changeSummary.onlyRequestInlineEdits,
                 includeInlineEdits: this._inlineEditsEnabled.read(reader),
             };
+            if (context.triggerKind === InlineCompletionTriggerKind.Automatic) {
+                if (this.textModel.getAlternativeVersionId() === this._lastShownInlineCompletionInfo?.alternateTextModelVersionId) {
+                    context = {
+                        ...context,
+                        includeInlineCompletions: !this._lastShownInlineCompletionInfo.inlineCompletion.isInlineEdit,
+                        includeInlineEdits: this._lastShownInlineCompletionInfo.inlineCompletion.isInlineEdit,
+                    };
+                }
+            }
             const itemToPreserveCandidate = this.selectedInlineCompletion.get() ?? this._inlineCompletionItems.get()?.inlineEdit;
             const itemToPreserve = changeSummary.preserveCurrentCompletion || itemToPreserveCandidate?.forwardStable
                 ? itemToPreserveCandidate : undefined;
-            return this._source.fetch(cursorPosition, context, itemToPreserve, changeSummary.shouldDebounce);
+            const userJumpedToActiveCompletion = ( this._jumpedToId.map(
+                jumpedTo => !!jumpedTo && jumpedTo === this._inlineCompletionItems.get()?.inlineEdit?.semanticId
+            ));
+            return this._source.fetch(cursorPosition, context, itemToPreserve, changeSummary.shouldDebounce, userJumpedToActiveCompletion);
         });
         this._inlineCompletionItems = derivedOpts({ owner: this }, reader => {
             const c = this._source.inlineCompletions.read(reader);
@@ -227,13 +270,11 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                     return undefined;
                 }
                 const commands = inlineEditResult.inlineCompletion.source.inlineCompletions.commands;
-                const renderExplicitly = this._jumpedTo.read(reader);
-                const inlineEdit = ( new InlineEdit(edit, renderExplicitly, commands ?? [], inlineEditResult.inlineCompletion));
+                const inlineEdit = ( new InlineEdit(edit, commands ?? [], inlineEditResult.inlineCompletion));
                 const edits = inlineEditResult.updatedEdit.read(reader);
                 const e = edits ? TextEdit.fromOffsetEdit(edits, ( new TextModelText(this.textModel))).edits : [edit];
                 return { kind: 'inlineEdit', inlineEdit, inlineCompletion: inlineEditResult, edits: e, cursorAtInlineEdit };
             }
-            this._jumpedTo.set(false, undefined);
             const suggestItem = this._selectedSuggestItem.read(reader);
             if (suggestItem) {
                 const suggestCompletionEdit = singleTextRemoveCommonPrefix(suggestItem.toSingleTextEdit(), model);
@@ -327,6 +368,16 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             }
             return v?.primaryGhostText;
         });
+        this.showCollapsed = derived(this, reader => {
+            const state = this.state.read(reader);
+            if (!state || state.kind !== 'inlineEdit') {
+                return false;
+            }
+            const isCurrentModelVersion = state.inlineCompletion.updatedEditModelVersion === this._textModelVersionId.read(reader);
+            return (this._inlineEditsShowCollapsedEnabled.read(reader) || !isCurrentModelVersion)
+                && this._jumpedToId.read(reader) !== state.inlineCompletion.semanticId
+                && !this._inAcceptFlow.read(reader);
+        });
         this._tabShouldIndent = derived(this, reader => {
             if (this._inAcceptFlow.read(reader)) {
                 return false;
@@ -358,8 +409,8 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (!s) {
                 return false;
             }
-            if (this._inlineEditsShowCollapsed.read(reader)) {
-                return !this._jumpedTo.read(reader);
+            if (this.showCollapsed.read(reader)) {
+                return true;
             }
             return !s.cursorAtInlineEdit;
         });
@@ -368,13 +419,13 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (!s) {
                 return false;
             }
-            if (this._inlineEditsShowCollapsed.read(reader)) {
-                return this._jumpedTo.read(reader);
+            if (this.showCollapsed.read(reader)) {
+                return false;
             }
             if (s.inlineEdit.range.startLineNumber === this._editorObs.cursorLineNumber.read(reader)) {
                 return true;
             }
-            if (this._jumpedTo.read(reader)) {
+            if (this._jumpedToId.read(reader) === s.inlineCompletion.semanticId) {
                 return true;
             }
             if (this._tabShouldIndent.read(reader)) {
@@ -383,8 +434,8 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             return s.cursorAtInlineEdit;
         });
         this._inAcceptPartialFlow = observableValue(this, false);
-        this.inAcceptPartialFlow = this._inAcceptPartialFlow;
-        this._jumpedTo = observableValue(this, false);
+        this.inPartialAcceptFlow = this._inAcceptPartialFlow;
+        this._jumpedToId = observableValue(this, undefined);
         this._inAcceptFlow = observableValue(this, false);
         this.inAcceptFlow = this._inAcceptFlow;
         this._register(recomputeInitiallyAndOnChange(this._fetchInlineCompletionsPromise));
@@ -417,6 +468,24 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             this._editorObs.versionId.read(reader);
             this._inAcceptFlow.set(false, undefined);
         }));
+        this._register(autorun(reader => {
+            const jumpToReset = ( this.state.map(s => !s || s.kind === 'inlineEdit' && !s.cursorAtInlineEdit)).read(reader);
+            if (jumpToReset) {
+                this._jumpedToId.set(undefined, undefined);
+            }
+        }));
+        const inlineEditSemanticId = ( this.inlineEditState.map(s => s?.inlineCompletion.semanticId));
+        this._register(autorun(reader => {
+            const id = inlineEditSemanticId.read(reader);
+            if (id) {
+                this._editor.pushUndoStop();
+                this._lastShownInlineCompletionInfo = {
+                    alternateTextModelVersionId: this.textModel.getAlternativeVersionId(),
+                    inlineCompletion: this.state.get().inlineCompletion.inlineCompletion,
+                };
+            }
+        }));
+        this._didUndoInlineEdits.recomputeInitiallyAndOnChange(this._store);
     }
     debugGetSelectedSuggestItem() {
         return this._selectedSuggestItem;
@@ -573,6 +642,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 })));
             }
         }
+        this._onDidAccept.fire();
         this.stop();
         if (completion.command) {
             await this._commandService
@@ -581,6 +651,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             completion.source.removeRef();
         }
         this._inAcceptFlow.set(true, undefined);
+        this._lastAcceptedInlineCompletionInfo = { textModelVersionIdAfter: this.textModel.getVersionId(), inlineCompletion: completion };
     }
     async acceptNextWord(editor) {
         await this._acceptNext(editor, (pos, text) => {
@@ -754,7 +825,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             return;
         }
         transaction(tx => {
-            this._jumpedTo.set(true, tx);
+            this._jumpedToId.set(s.inlineCompletion.semanticId, tx);
             this.dontRefetchSignal.trigger(tx);
             const edit = s.inlineCompletion.toSingleTextEdit(undefined);
             this._editor.setPosition(edit.range.getStartPosition(), 'inlineCompletions.jump');

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineCompletionsSource.d.ts

@@ -1,8 +1,6 @@
 import { Disposable, IDisposable } from "../../../../../base/common/lifecycle.js";
 import { IObservable, IObservableWithChange, IReader, ITransaction } from "../../../../../base/common/observable.js";
-import { ICommandService } from "../../../../../platform/commands/common/commands.service.js";
 import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
-import { IContextKeyService } from "../../../../../platform/contextkey/common/contextkey.service.js";
 import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
 import { ILogService } from "../../../../../platform/log/common/log.service.js";
 import { OffsetEdit } from "../../../../common/core/offsetEdit.js";
@@ -32,10 +30,11 @@ export declare class InlineCompletionsSource extends Disposable {
     private readonly _loggingEnabled;
     private readonly _structuredFetchLogger;
     constructor(_textModel: ITextModel, _versionId: IObservableWithChange<number | null, IModelContentChangedEvent | undefined>, _debounceValue: IFeatureDebounceInformation, _languageFeaturesService: ILanguageFeaturesService, _languageConfigurationService: ILanguageConfigurationService, _logService: ILogService, _configurationService: IConfigurationService, _instantiationService: IInstantiationService);
+    readonly clearOperationOnTextModelChange: IObservable<undefined>;
     private _log;
     private readonly _loadingCount;
     readonly loading: IObservable<boolean>;
-    fetch(position: Position, context: InlineCompletionContext, activeInlineCompletion: InlineCompletionWithUpdatedRange | undefined, withDebounce: boolean): Promise<boolean>;
+    fetch(position: Position, context: InlineCompletionContext, activeInlineCompletion: InlineCompletionWithUpdatedRange | undefined, withDebounce: boolean, userJumpedToActiveCompletion: IObservable<boolean>): Promise<boolean>;
     clear(tx: ITransaction): void;
     clearSuggestWidgetInlineCompletions(tx: ITransaction): void;
     cancelUpdate(): void;
@@ -69,39 +68,21 @@ export declare class InlineCompletionWithUpdatedRange extends Disposable {
     readonly request: UpdateRequest;
     readonly semanticId: string;
     get forwardStable(): boolean;
-    private _updatedEdit;
+    private readonly _updatedEditObj;
     get updatedEdit(): IObservable<OffsetEdit | undefined>;
-    private readonly _updatedRange;
+    get updatedEditModelVersion(): number;
     get source(): import("./provideInlineCompletions.js").InlineCompletionList;
     get sourceInlineCompletion(): import("../../../../common/languages.js").InlineCompletion;
-    get isInlineEdit(): boolean | undefined;
+    get isInlineEdit(): boolean;
     constructor(inlineCompletion: InlineCompletionItem, updatedRange: Range | undefined, _textModel: ITextModel, _modelVersion: IObservableWithChange<number | null, IModelContentChangedEvent | undefined>, request: UpdateRequest);
-    private _toInlineCompletionEdit;
-    private _toUpdatedEdit;
     toInlineCompletion(reader: IReader | undefined): InlineCompletionItem;
     toSingleTextEdit(reader: IReader | undefined): SingleTextEdit;
     isVisible(model: ITextModel, cursorPosition: Position, reader: IReader | undefined): boolean;
+    reuse(): void;
     canBeReused(model: ITextModel, position: Position): boolean;
-    private _toFilterTextReplacement;
-}
-interface IRecordableLogEntry {
-    sourceId: string;
-    time: number;
-}
-export interface IRecordableEditorLogEntry extends IRecordableLogEntry {
-    modelUri: string;
-    modelVersion: number;
-}
-export declare function formatRecordableLogEntry<T extends IRecordableLogEntry>(entry: T): string;
-export declare class StructuredLogger<T extends IRecordableLogEntry> extends Disposable {
-    private readonly _contextKey;
-    private readonly _contextKeyService;
-    private readonly _commandService;
-    static cast<T extends IRecordableLogEntry>(): typeof StructuredLogger<T>;
-    private readonly _contextKeyValue;
-    constructor(_contextKey: string, _contextKeyService: IContextKeyService, _commandService: ICommandService);
-    readonly isEnabled: IObservable<boolean>;
-    log(data: T): boolean;
+    private readonly _updatedRange;
+    private _toUpdatedEdit;
+    private _toInlineCompletionEdit;
+    private _toInlineEditEdit;
 }
-export declare function observableContextKey<T>(key: string, contextKeyService: IContextKeyService): IObservable<T | undefined>;
 export {};

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineCompletionsSource.js

@@ -9,16 +9,14 @@ import { matchesSubString } from '../../../../../base/common/filters.js';
 import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
 import '../../../../../base/common/observableInternal/index.js';
 import { splitLines, commonPrefixLength, commonSuffixLength } from '../../../../../base/common/strings.js';
-import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
-import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../../platform/log/common/log.service.js';
 import { observableConfigValue } from '../../../../../platform/observable/common/platformObservableUtils.js';
 import { OffsetEdit, SingleOffsetEdit, applyEditsToRanges } from '../../../../common/core/offsetEdit.js';
 import { OffsetRange } from '../../../../common/core/offsetRange.js';
 import { Range } from '../../../../common/core/range.js';
-import { StringText, SingleTextEdit } from '../../../../common/core/textEdit.js';
+import { SingleTextEdit, StringText } from '../../../../common/core/textEdit.js';
 import { TextLength } from '../../../../common/core/textLength.js';
 import { linesDiffComputers } from '../../../../common/diff/linesDiffComputers.js';
 import { InlineCompletionTriggerKind } from '../../../../common/languages.js';
@@ -28,9 +26,9 @@ import { OffsetEdits } from '../../../../common/model/textModelOffsetEdit.js';
 import { ILanguageFeaturesService } from '../../../../common/services/languageFeatures.service.js';
 import { provideInlineCompletions } from './provideInlineCompletions.js';
 import { singleTextRemoveCommonPrefix } from './singleTextEditHelpers.js';
+import { StructuredLogger, formatRecordableLogEntry } from '../structuredLogger.js';
 import { derived, derivedHandleChanges } from '../../../../../base/common/observableInternal/derived.js';
 import { disposableObservableValue, observableValue, transaction } from '../../../../../base/common/observableInternal/base.js';
-import { observableFromEvent } from '../../../../../base/common/observableInternal/utils.js';
 
 var InlineCompletionsSource_1;
 let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
@@ -51,11 +49,14 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         this.suggestWidgetInlineCompletions = this._register(disposableObservableValue('suggestWidgetInlineCompletions', undefined));
         this._loggingEnabled = observableConfigValue('editor.inlineSuggest.logFetch', false, this._configurationService).recomputeInitiallyAndOnChange(this._store);
         this._structuredFetchLogger = this._register(this._instantiationService.createInstance(StructuredLogger.cast(), 'editor.inlineSuggest.logFetch.commandId'));
+        this.clearOperationOnTextModelChange = derived(this, reader => {
+            this._versionId.read(reader);
+            this._updateOperation.clear();
+            return undefined;
+        });
         this._loadingCount = observableValue(this, 0);
         this.loading = ( this._loadingCount.map(this, v => v > 0));
-        this._register(this._textModel.onDidChangeContent((e) => {
-            this._updateOperation.clear();
-        }));
+        this.clearOperationOnTextModelChange.recomputeInitiallyAndOnChange(this._store);
     }
     _log(entry) {
         if (this._loggingEnabled.get()) {
@@ -63,7 +64,7 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         }
         this._structuredFetchLogger.log(entry);
     }
-    fetch(position, context, activeInlineCompletion, withDebounce) {
+    fetch(position, context, activeInlineCompletion, withDebounce, userJumpedToActiveCompletion) {
         const request = ( new UpdateRequest(position, context, this._textModel.getVersionId()));
         const target = context.selectedSuggestionInfo ? this.suggestWidgetInlineCompletions : this.inlineCompletions;
         if (this._updateOperation.value?.request.satisfies(request)) {
@@ -109,17 +110,19 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
                         const result = updatedCompletions?.completions.map(c => ({
                             range: ( c.range.toString()),
                             text: c.insertText,
-                            isInlineEdit: !!c.sourceInlineCompletion.isInlineEdit,
+                            isInlineEdit: !!c.isInlineEdit,
                             source: c.source.provider.groupId,
                         }));
                         this._log({ sourceId: 'InlineCompletions.fetch', kind: 'end', requestId, durationMs: (Date.now() - startTime.getTime()), error, result, time: Date.now() });
                     }
                 }
-                if (source.token.isCancellationRequested || this._store.isDisposed || this._textModel.getVersionId() !== request.versionId) {
+                if (source.token.isCancellationRequested || this._store.isDisposed || this._textModel.getVersionId() !== request.versionId || userJumpedToActiveCompletion.get() ) {
                     updatedCompletions.dispose();
                     return false;
                 }
-                if (activeInlineCompletion && activeInlineCompletion.isInlineEdit && ((activeInlineCompletion.canBeReused(this._textModel, position) || ( updatedCompletions.has(activeInlineCompletion.inlineCompletion))) )) {
+                if (activeInlineCompletion && activeInlineCompletion.isInlineEdit && activeInlineCompletion.updatedEditModelVersion === this._textModel.getVersionId() && ((activeInlineCompletion.canBeReused(this._textModel, position)
+                    || ( updatedCompletions.has(activeInlineCompletion.inlineCompletion))  || updatedCompletions.isEmpty()) )) {
+                    activeInlineCompletion.reuse();
                     updatedCompletions.dispose();
                     return false;
                 }
@@ -252,10 +255,11 @@ class InlineCompletionWithUpdatedRange extends Disposable {
     get forwardStable() {
         return this.source.inlineCompletions.enableForwardStability ?? false;
     }
-    get updatedEdit() { return this._updatedEdit.offsetEdit; }
+    get updatedEdit() { return this._updatedEditObj.offsetEdit; }
+    get updatedEditModelVersion() { return this._updatedEditObj.modelVersion; }
     get source() { return this.inlineCompletion.source; }
     get sourceInlineCompletion() { return this.inlineCompletion.sourceInlineCompletion; }
-    get isInlineEdit() { return this.inlineCompletion.sourceInlineCompletion.isInlineEdit; }
+    get isInlineEdit() { return this.inlineCompletion.isInlineEdit; }
     constructor(inlineCompletion, updatedRange, _textModel, _modelVersion, request) {
         super();
         this.inlineCompletion = inlineCompletion;
@@ -274,48 +278,7 @@ class InlineCompletionWithUpdatedRange extends Disposable {
             }
             return Range.fromPositions(this._textModel.getPositionAt(edit.edits[0].replaceRange.start), this._textModel.getPositionAt(edit.edits[edit.edits.length - 1].replaceRange.endExclusive));
         });
-        this._updatedEdit = this._register(this._toUpdatedEdit(updatedRange ?? this.inlineCompletion.range, this.inlineCompletion.insertText));
-    }
-    _toInlineCompletionEdit(editRange, replaceText) {
-        const startOffset = this._textModel.getOffsetAt(editRange.getStartPosition());
-        const endOffset = this._textModel.getOffsetAt(editRange.getEndPosition());
-        const originalRange = OffsetRange.ofStartAndLength(startOffset, endOffset - startOffset);
-        const offsetEdit = ( new OffsetEdit([( new SingleOffsetEdit(originalRange, replaceText))]));
-        return ( new UpdatedEdit(offsetEdit, this._textModel, this._modelVersion, false));
-    }
-    _toUpdatedEdit(editRange, replaceText) {
-        if (!this.isInlineEdit) {
-            return this._toInlineCompletionEdit(editRange, replaceText);
-        }
-        const eol = this._textModel.getEOL();
-        const editOriginalText = this._textModel.getValueInRange(editRange);
-        const editReplaceText = replaceText.replace(/\r\n|\r|\n/g, eol);
-        const diffAlgorithm = linesDiffComputers.getDefault();
-        const lineDiffs = diffAlgorithm.computeDiff(splitLines(editOriginalText), splitLines(editReplaceText), {
-            ignoreTrimWhitespace: false,
-            computeMoves: false,
-            extendToSubwords: true,
-            maxComputationTimeMs: 500,
-        });
-        const innerChanges = lineDiffs.changes.flatMap(c => c.innerChanges ?? []);
-        function addRangeToPos(pos, range) {
-            const start = TextLength.fromPosition(range.getStartPosition());
-            return TextLength.ofRange(range).createRange(start.addToPosition(pos));
-        }
-        const modifiedText = ( new StringText(editReplaceText));
-        const offsetEdit = ( new OffsetEdit(( innerChanges.map(c => {
-            const range = addRangeToPos(editRange.getStartPosition(), c.originalRange);
-            const startOffset = this._textModel.getOffsetAt(range.getStartPosition());
-            const endOffset = this._textModel.getOffsetAt(range.getEndPosition());
-            const originalRange = OffsetRange.ofStartAndLength(startOffset, endOffset - startOffset);
-            const replaceText = modifiedText.getValueOfRange(c.modifiedRange);
-            const oldText = this._textModel.getValueInRange(range);
-            if (replaceText.endsWith(eol) && oldText.endsWith(eol)) {
-                return ( new SingleOffsetEdit(originalRange.deltaEnd(-eol.length), replaceText.slice(0, -eol.length)));
-            }
-            return ( new SingleOffsetEdit(originalRange, replaceText));
-        }))));
-        return ( new UpdatedEdit(offsetEdit, this._textModel, this._modelVersion, true));
+        this._updatedEditObj = this._register(this._toUpdatedEdit(updatedRange ?? this.inlineCompletion.range, this.inlineCompletion.insertText));
     }
     toInlineCompletion(reader) {
         const singleTextEdit = this.toSingleTextEdit(reader);
@@ -344,7 +307,7 @@ class InlineCompletionWithUpdatedRange extends Disposable {
         return ( new SingleTextEdit(overallLnColRange, text));
     }
     isVisible(model, cursorPosition, reader) {
-        const minimizedReplacement = singleTextRemoveCommonPrefix(this._toFilterTextReplacement(reader), model);
+        const minimizedReplacement = singleTextRemoveCommonPrefix(this.toSingleTextEdit(reader), model);
         const updatedRange = this._updatedRange.read(reader);
         if (!updatedRange
             || !this.inlineCompletion.range.getStartPosition().equals(updatedRange.getStartPosition())
@@ -374,12 +337,15 @@ class InlineCompletionWithUpdatedRange extends Disposable {
         return filterTextBefore.startsWith(originalValueBefore)
             && !!matchesSubString(originalValueAfter, filterTextAfter);
     }
+    reuse() {
+        this._updatedEditObj.reuse();
+    }
     canBeReused(model, position) {
         if (!this.updatedEdit.get()) {
             return false;
         }
         if (this.sourceInlineCompletion.isInlineEdit) {
-            return this._updatedEdit.lastChangePartOfInlineEdit;
+            return this._updatedEditObj.lastChangePartOfInlineEdit;
         }
         const updatedRange = this._updatedRange.read(undefined);
         const result = !!updatedRange
@@ -388,18 +354,56 @@ class InlineCompletionWithUpdatedRange extends Disposable {
             && TextLength.ofRange(updatedRange).isGreaterThanOrEqualTo(TextLength.ofRange(this.inlineCompletion.range));
         return result;
     }
-    _toFilterTextReplacement(reader) {
-        const inlineCompletion = this.toInlineCompletion(reader);
-        return ( new SingleTextEdit(inlineCompletion.range, inlineCompletion.filterText));
+    _toUpdatedEdit(editRange, replaceText) {
+        return this.isInlineEdit
+            ? this._toInlineEditEdit(editRange, replaceText)
+            : this._toInlineCompletionEdit(editRange, replaceText);
+    }
+    _toInlineCompletionEdit(editRange, replaceText) {
+        const startOffset = this._textModel.getOffsetAt(editRange.getStartPosition());
+        const endOffset = this._textModel.getOffsetAt(editRange.getEndPosition());
+        const originalRange = OffsetRange.ofStartAndLength(startOffset, endOffset - startOffset);
+        const offsetEdit = ( new OffsetEdit([( new SingleOffsetEdit(originalRange, replaceText))]));
+        return ( new UpdatedEdit(offsetEdit, this._textModel, this._modelVersion, false));
+    }
+    _toInlineEditEdit(editRange, replaceText) {
+        const eol = this._textModel.getEOL();
+        const editOriginalText = this._textModel.getValueInRange(editRange);
+        const editReplaceText = replaceText.replace(/\r\n|\r|\n/g, eol);
+        const diffAlgorithm = linesDiffComputers.getDefault();
+        const lineDiffs = diffAlgorithm.computeDiff(splitLines(editOriginalText), splitLines(editReplaceText), {
+            ignoreTrimWhitespace: false,
+            computeMoves: false,
+            extendToSubwords: true,
+            maxComputationTimeMs: 500,
+        });
+        const innerChanges = lineDiffs.changes.flatMap(c => c.innerChanges ?? []);
+        function addRangeToPos(pos, range) {
+            const start = TextLength.fromPosition(range.getStartPosition());
+            return TextLength.ofRange(range).createRange(start.addToPosition(pos));
+        }
+        const modifiedText = ( new StringText(editReplaceText));
+        const offsetEdit = ( new OffsetEdit(( innerChanges.map(c => {
+            const range = addRangeToPos(editRange.getStartPosition(), c.originalRange);
+            const startOffset = this._textModel.getOffsetAt(range.getStartPosition());
+            const endOffset = this._textModel.getOffsetAt(range.getEndPosition());
+            const originalRange = OffsetRange.ofStartAndLength(startOffset, endOffset - startOffset);
+            const replaceText = modifiedText.getValueOfRange(c.modifiedRange);
+            const originalText = this._textModel.getValueInRange(range);
+            const edit = ( new SingleOffsetEdit(originalRange, replaceText));
+            return reshapeEdit(edit, originalText, innerChanges.length, this._textModel);
+        }))));
+        return ( new UpdatedEdit(offsetEdit, this._textModel, this._modelVersion, true));
     }
 }
 class UpdatedEdit extends Disposable {
+    get modelVersion() { return this._inlineEditModelVersion; }
     get lastChangePartOfInlineEdit() { return this._lastChangePartOfInlineEdit; }
     get offsetEdit() { return ( this._updatedEdit.map(e => e ?? undefined)); }
-    constructor(offsetEdit, textModel, _modelVersion, isInlineEdit) {
+    constructor(offsetEdit, _textModel, _modelVersion, isInlineEdit) {
         super();
+        this._textModel = _textModel;
         this._modelVersion = _modelVersion;
-        this._invalidationTime = Date.now() + 3000;
         this._lastChangePartOfInlineEdit = false;
         this._updatedEdit = derivedHandleChanges({
             owner: this,
@@ -416,9 +420,6 @@ class UpdatedEdit extends Disposable {
             for (const change of changeSummary) {
                 this._innerEdits = this._applyTextModelChanges(change, this._innerEdits);
             }
-            if (this._hasInvalidationTimePassed()) {
-                return undefined;
-            }
             if (this._innerEdits.length === 0) {
                 return undefined;
             }
@@ -427,10 +428,11 @@ class UpdatedEdit extends Disposable {
             }
             return ( new OffsetEdit(( this._innerEdits.map(edit => edit.edit))));
         });
+        this._inlineEditModelVersion = this._modelVersion.get() ?? -1;
         this._innerEdits = ( offsetEdit.edits.map(edit => {
             if (isInlineEdit) {
-                const replacedRange = Range.fromPositions(textModel.getPositionAt(edit.replaceRange.start), textModel.getPositionAt(edit.replaceRange.endExclusive));
-                const replacedText = textModel.getValueInRange(replacedRange);
+                const replacedRange = Range.fromPositions(this._textModel.getPositionAt(edit.replaceRange.start), this._textModel.getPositionAt(edit.replaceRange.endExclusive));
+                const replacedText = this._textModel.getValueInRange(replacedRange);
                 return ( new SingleUpdatedNextEdit(edit, replacedText));
             }
             return ( new SingleUpdatedCompletion(edit));
@@ -444,9 +446,13 @@ class UpdatedEdit extends Disposable {
         if (( edits.some(edit => edit.edit === undefined))) {
             return [];
         }
+        const currentModelVersion = this._modelVersion.get();
         this._lastChangePartOfInlineEdit = ( edits.some(edit => edit.lastChangeUpdatedEdit));
         if (this._lastChangePartOfInlineEdit) {
-            this._cancelInvalidationTimer();
+            this._inlineEditModelVersion = currentModelVersion ?? -1;
+        }
+        if (currentModelVersion === null || this._inlineEditModelVersion + 20 < currentModelVersion) {
+            return [];
         }
         edits = edits.filter(innerEdit => !innerEdit.edit.isEmpty);
         if (edits.length === 0) {
@@ -454,11 +460,8 @@ class UpdatedEdit extends Disposable {
         }
         return edits;
     }
-    _cancelInvalidationTimer() {
-        this._invalidationTime = undefined;
-    }
-    _hasInvalidationTimePassed() {
-        return !!this._invalidationTime && this._invalidationTime < Date.now();
+    reuse() {
+        this._inlineEditModelVersion = this._modelVersion.get() ?? -1;
     }
 }
 class SingleUpdatedEdit {
@@ -550,36 +553,47 @@ class SingleUpdatedNextEdit extends SingleUpdatedEdit {
     }
 }
 const emptyRange = ( new Range(1, 1, 1, 1));
-function formatRecordableLogEntry(entry) {
-    return entry.sourceId + ' @@ ' + JSON.stringify({ ...entry, sourceId: undefined });
+function reshapeEdit(edit, originalText, totalInnerEdits, textModel) {
+    const eol = textModel.getEOL();
+    if (edit.newText.endsWith(eol) && originalText.endsWith(eol)) {
+        edit = ( new SingleOffsetEdit(
+            edit.replaceRange.deltaEnd(-eol.length),
+            edit.newText.slice(0, -eol.length)
+        ));
+    }
+    if (totalInnerEdits === 1 && edit.replaceRange.isEmpty && edit.newText.includes(eol)) {
+        edit = reshapeMultiLineInsertion(edit, textModel);
+    }
+    if (totalInnerEdits === 1) {
+        const prefixLength = commonPrefixLength(originalText, edit.newText);
+        const suffixLength = commonSuffixLength(originalText.slice(prefixLength), edit.newText.slice(prefixLength));
+        if (prefixLength + suffixLength === originalText.length) {
+            return ( new SingleOffsetEdit(
+                edit.replaceRange.deltaStart(prefixLength).deltaEnd(-suffixLength),
+                edit.newText.substring(prefixLength, edit.newText.length - suffixLength)
+            ));
+        }
+        if (prefixLength + suffixLength === edit.newText.length) {
+            return ( new SingleOffsetEdit(edit.replaceRange.deltaStart(prefixLength).deltaEnd(-suffixLength), ''));
+        }
+    }
+    return edit;
 }
-let StructuredLogger = class StructuredLogger extends Disposable {
-    static cast() {
-        return this;
+function reshapeMultiLineInsertion(edit, textModel) {
+    if (!edit.replaceRange.isEmpty) {
+        throw ( new BugIndicatingError('Unexpected original range'));
     }
-    constructor(_contextKey, _contextKeyService, _commandService) {
-        super();
-        this._contextKey = _contextKey;
-        this._contextKeyService = _contextKeyService;
-        this._commandService = _commandService;
-        this._contextKeyValue = observableContextKey(this._contextKey, this._contextKeyService).recomputeInitiallyAndOnChange(this._store);
-        this.isEnabled = ( this._contextKeyValue.map(v => v !== undefined));
-    }
-    log(data) {
-        const commandId = this._contextKeyValue.get();
-        if (!commandId) {
-            return false;
-        }
-        this._commandService.executeCommand(commandId, data);
-        return true;
+    if (edit.replaceRange.start === 0) {
+        return edit;
     }
-};
-StructuredLogger = ( __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, ICommandService))
-], StructuredLogger));
-function observableContextKey(key, contextKeyService) {
-    return observableFromEvent(contextKeyService.onDidChangeContext, () => contextKeyService.getContextKeyValue(key));
+    const eol = textModel.getEOL();
+    const startPosition = textModel.getPositionAt(edit.replaceRange.start);
+    const startColumn = startPosition.column;
+    const startLineNumber = startPosition.lineNumber;
+    if (startColumn === 1 && startLineNumber > 1 && textModel.getLineLength(startLineNumber) !== 0 && edit.newText.endsWith(eol) && !edit.newText.startsWith(eol)) {
+        return ( new SingleOffsetEdit(edit.replaceRange.delta(-1), eol + edit.newText.slice(0, -eol.length)));
+    }
+    return edit;
 }
 
-export { InlineCompletionWithUpdatedRange, InlineCompletionsSource, StructuredLogger, UpToDateInlineCompletions, formatRecordableLogEntry, observableContextKey };
+export { InlineCompletionWithUpdatedRange, InlineCompletionsSource, UpToDateInlineCompletions };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineEdit.d.ts

@@ -3,10 +3,9 @@ import { Command } from "../../../../common/languages.js";
 import { InlineCompletionItem } from "./provideInlineCompletions.js";
 export declare class InlineEdit {
     readonly edit: SingleTextEdit;
-    readonly renderExplicitly: boolean;
     readonly commands: readonly Command[];
     readonly inlineCompletion: InlineCompletionItem;
-    constructor(edit: SingleTextEdit, renderExplicitly: boolean, commands: readonly Command[], inlineCompletion: InlineCompletionItem);
+    constructor(edit: SingleTextEdit, commands: readonly Command[], inlineCompletion: InlineCompletionItem);
     get range(): import("../../../../common/core/range.js").Range;
     get text(): string;
     equals(other: InlineEdit): boolean;