@codingame/monaco-vscode-api 16.1.0 → 17.0.0

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

@@ -4,51 +4,73 @@ import { compareUndefinedSmallest, numberComparator } from '../../../../../base/
 import { findLastMax } from '../../../../../base/common/arraysFind.js';
 import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
 import { equalsIfDefined, itemEquals } from '../../../../../base/common/equals.js';
-import { BugIndicatingError } from '../../../../../base/common/errors.js';
-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 { observableReducerSettable } from '../../../../../base/common/observableInternal/reducer.js';
+import { isDefined } from '../../../../../base/common/types.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.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 { 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';
+import { OffsetEdit } from '../../../../common/core/offsetEdit.js';
+import { InlineCompletionTriggerKind, InlineCompletionEndOfLifeReasonKind } from '../../../../common/languages.js';
 import { ILanguageConfigurationService } from '../../../../common/languages/languageConfigurationRegistry.service.js';
-import { EndOfLinePreference } from '../../../../common/model.js';
 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 { wait } from '../utils.js';
+import { InlineSuggestionItem } from './inlineSuggestionItem.js';
+import { provideInlineCompletions } from './provideInlineCompletions.js';
+import { recordChanges } from '../../../../../base/common/observableInternal/changeTracker.js';
+import { derived } from '../../../../../base/common/observableInternal/derived.js';
+import { observableValue, transaction } from '../../../../../base/common/observableInternal/base.js';
 
 var InlineCompletionsSource_1;
 let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
     static { InlineCompletionsSource_1 = this; }
     static { this._requestId = 0; }
-    constructor(_textModel, _versionId, _debounceValue, _languageFeaturesService, _languageConfigurationService, _logService, _configurationService, _instantiationService) {
+    constructor(_textModel, _versionId, _debounceValue, _languageConfigurationService, _logService, _configurationService, _instantiationService) {
         super();
         this._textModel = _textModel;
         this._versionId = _versionId;
         this._debounceValue = _debounceValue;
-        this._languageFeaturesService = _languageFeaturesService;
         this._languageConfigurationService = _languageConfigurationService;
         this._logService = _logService;
         this._configurationService = _configurationService;
         this._instantiationService = _instantiationService;
         this._updateOperation = this._register(( new MutableDisposable()));
-        this.inlineCompletions = this._register(disposableObservableValue('inlineCompletions', undefined));
-        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._state = observableReducerSettable(this, {
+            initial: () => ({
+                inlineCompletions: InlineCompletionsState.createEmpty(),
+                suggestWidgetInlineCompletions: InlineCompletionsState.createEmpty(),
+            }),
+            disposeFinal: (values) => {
+                values.inlineCompletions.dispose();
+                values.suggestWidgetInlineCompletions.dispose();
+            },
+            changeTracker: recordChanges({ versionId: this._versionId }),
+            update: (reader, previousValue, changes) => {
+                const edit = OffsetEdit.join(( changes.changes.map(
+                    c => c.change ? OffsetEdits.fromContentChanges(c.change.changes) : OffsetEdit.empty
+                )).filter(isDefined));
+                if (edit.isEmpty) {
+                    return previousValue;
+                }
+                try {
+                    return {
+                        inlineCompletions: previousValue.inlineCompletions.createStateWithAppliedEdit(edit, this._textModel),
+                        suggestWidgetInlineCompletions: previousValue.suggestWidgetInlineCompletions.createStateWithAppliedEdit(edit, this._textModel),
+                    };
+                }
+                finally {
+                    previousValue.inlineCompletions.dispose();
+                    previousValue.suggestWidgetInlineCompletions.dispose();
+                }
+            }
+        });
+        this.inlineCompletions = ( this._state.map(this, v => v.inlineCompletions));
+        this.suggestWidgetInlineCompletions = ( this._state.map(this, v => v.suggestWidgetInlineCompletions));
         this.clearOperationOnTextModelChange = derived(this, reader => {
             this._versionId.read(reader);
             this._updateOperation.clear();
@@ -64,13 +86,13 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         }
         this._structuredFetchLogger.log(entry);
     }
-    fetch(position, context, activeInlineCompletion, withDebounce, userJumpedToActiveCompletion) {
+    fetch(providers, position, context, activeInlineCompletion, withDebounce, userJumpedToActiveCompletion, providerhasChangedCompletion) {
         const request = ( new UpdateRequest(position, context, this._textModel.getVersionId()));
-        const target = context.selectedSuggestionInfo ? this.suggestWidgetInlineCompletions : this.inlineCompletions;
-        if (this._updateOperation.value?.request.satisfies(request)) {
+        const target = context.selectedSuggestionInfo ? this.suggestWidgetInlineCompletions.get() : this.inlineCompletions.get();
+        if (!providerhasChangedCompletion && this._updateOperation.value?.request.satisfies(request)) {
             return this._updateOperation.value.promise;
         }
-        else if (target.get()?.request.satisfies(request)) {
+        else if (target?.request?.satisfies(request)) {
             return Promise.resolve(true);
         }
         const updateOngoing = !!this._updateOperation.value;
@@ -80,7 +102,7 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
             this._loadingCount.set(this._loadingCount.get() + 1, undefined);
             try {
                 const recommendedDebounceValue = this._debounceValue.get(this._textModel);
-                const debounceValue = findLastMax(( this._languageFeaturesService.inlineCompletionsProvider.all(this._textModel).map(p => p.debounceDelayMs)), compareUndefinedSmallest(numberComparator)) ?? recommendedDebounceValue;
+                const debounceValue = findLastMax(( providers.map(p => p.debounceDelayMs)), compareUndefinedSmallest(numberComparator)) ?? recommendedDebounceValue;
                 const shouldDebounce = updateOngoing || (withDebounce && context.triggerKind === InlineCompletionTriggerKind.Automatic);
                 if (shouldDebounce) {
                     await wait(debounceValue, source.token);
@@ -93,10 +115,10 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
                     this._log({ sourceId: 'InlineCompletions.fetch', kind: 'start', requestId, modelUri: ( this._textModel.uri.toString()), modelVersion: this._textModel.getVersionId(), context: { triggerKind: context.triggerKind }, time: Date.now() });
                 }
                 const startTime = ( new Date());
-                let updatedCompletions = undefined;
+                let providerResult = undefined;
                 let error = undefined;
                 try {
-                    updatedCompletions = await provideInlineCompletions(this._languageFeaturesService.inlineCompletionsProvider, position, this._textModel, context, source.token, this._languageConfigurationService);
+                    providerResult = await provideInlineCompletions(providers, position, this._textModel, context, source.token, this._languageConfigurationService);
                 }
                 catch (e) {
                     error = e;
@@ -107,7 +129,7 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
                         if (source.token.isCancellationRequested || this._store.isDisposed || this._textModel.getVersionId() !== request.versionId) {
                             error = 'canceled';
                         }
-                        const result = updatedCompletions?.completions.map(c => ({
+                        const result = providerResult?.completions.map(c => ({
                             range: ( c.range.toString()),
                             text: c.insertText,
                             isInlineEdit: !!c.isInlineEdit,
@@ -117,27 +139,29 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
                     }
                 }
                 if (source.token.isCancellationRequested || this._store.isDisposed || this._textModel.getVersionId() !== request.versionId || userJumpedToActiveCompletion.get() ) {
-                    updatedCompletions.dispose();
-                    return false;
-                }
-                if (activeInlineCompletion && activeInlineCompletion.isInlineEdit && activeInlineCompletion.updatedEditModelVersion === this._textModel.getVersionId() && ((activeInlineCompletion.canBeReused(this._textModel, position)
-                    || ( updatedCompletions.has(activeInlineCompletion.inlineCompletion))  || updatedCompletions.isEmpty()) )) {
-                    activeInlineCompletion.reuse();
-                    updatedCompletions.dispose();
+                    providerResult.dispose();
                     return false;
                 }
                 const endTime = ( new Date());
                 this._debounceValue.update(this._textModel, endTime.getTime() - startTime.getTime());
-                const completions = ( new UpToDateInlineCompletions(updatedCompletions, request, this._textModel, this._versionId));
-                if (activeInlineCompletion && !activeInlineCompletion.isInlineEdit && activeInlineCompletion.canBeReused(this._textModel, position)) {
-                    const asInlineCompletion = activeInlineCompletion.toInlineCompletion(undefined);
-                    if (!( updatedCompletions.has(asInlineCompletion))) {
-                        completions.prepend(activeInlineCompletion.inlineCompletion, asInlineCompletion.range, true);
-                    }
-                }
                 this._updateOperation.clear();
                 transaction(tx => {
-                    target.set(completions, tx);
+                    const v = this._state.get();
+                    if (context.selectedSuggestionInfo) {
+                        this._state.set({
+                            inlineCompletions: InlineCompletionsState.createEmpty(),
+                            suggestWidgetInlineCompletions: v.suggestWidgetInlineCompletions.createStateWithAppliedResults(providerResult, request, this._textModel, activeInlineCompletion),
+                        }, tx);
+                    }
+                    else {
+                        this._state.set({
+                            inlineCompletions: v.inlineCompletions.createStateWithAppliedResults(providerResult, request, this._textModel, activeInlineCompletion),
+                            suggestWidgetInlineCompletions: InlineCompletionsState.createEmpty(),
+                        }, tx);
+                    }
+                    providerResult.dispose();
+                    v.inlineCompletions.dispose();
+                    v.suggestWidgetInlineCompletions.dispose();
                 });
             }
             finally {
@@ -151,46 +175,49 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
     }
     clear(tx) {
         this._updateOperation.clear();
-        this.inlineCompletions.set(undefined, tx);
-        this.suggestWidgetInlineCompletions.set(undefined, tx);
+        const v = this._state.get();
+        this._state.set({
+            inlineCompletions: InlineCompletionsState.createEmpty(),
+            suggestWidgetInlineCompletions: InlineCompletionsState.createEmpty()
+        }, tx);
+        v.inlineCompletions.dispose();
+        v.suggestWidgetInlineCompletions.dispose();
+    }
+    seedInlineCompletionsWithSuggestWidget() {
+        const inlineCompletions = this.inlineCompletions.get();
+        const suggestWidgetInlineCompletions = this.suggestWidgetInlineCompletions.get();
+        if (!suggestWidgetInlineCompletions) {
+            return;
+        }
+        transaction(tx => {
+            if (!inlineCompletions || (suggestWidgetInlineCompletions.request?.versionId ?? -1) > (inlineCompletions.request?.versionId ?? -1)) {
+                inlineCompletions?.dispose();
+                const s = this._state.get();
+                this._state.set({
+                    inlineCompletions: suggestWidgetInlineCompletions.clone(),
+                    suggestWidgetInlineCompletions: InlineCompletionsState.createEmpty(),
+                }, tx);
+                s.inlineCompletions.dispose();
+                s.suggestWidgetInlineCompletions.dispose();
+            }
+            this.clearSuggestWidgetInlineCompletions(tx);
+        });
     }
     clearSuggestWidgetInlineCompletions(tx) {
         if (this._updateOperation.value?.request.context.selectedSuggestionInfo) {
             this._updateOperation.clear();
         }
-        this.suggestWidgetInlineCompletions.set(undefined, tx);
     }
     cancelUpdate() {
         this._updateOperation.clear();
     }
 };
 InlineCompletionsSource = InlineCompletionsSource_1 = ( __decorate([
-    ( __param(3, ILanguageFeaturesService)),
-    ( __param(4, ILanguageConfigurationService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IInstantiationService))
+    ( __param(3, ILanguageConfigurationService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IInstantiationService))
 ], InlineCompletionsSource));
-function wait(ms, cancellationToken) {
-    return ( new Promise(resolve => {
-        let d = undefined;
-        const handle = setTimeout(() => {
-            if (d) {
-                d.dispose();
-            }
-            resolve();
-        }, ms);
-        if (cancellationToken) {
-            d = cancellationToken.onCancellationRequested(() => {
-                clearTimeout(handle);
-                if (d) {
-                    d.dispose();
-                }
-                resolve();
-            });
-        }
-    }));
-}
 class UpdateRequest {
     constructor(position, context, versionId) {
         this.position = position;
@@ -218,382 +245,59 @@ class UpdateOperation {
         this.cancellationTokenSource.cancel();
     }
 }
-class UpToDateInlineCompletions {
-    get inlineCompletions() { return this._inlineCompletions; }
-    constructor(inlineCompletionProviderResult, request, _textModel, _versionId) {
-        this.inlineCompletionProviderResult = inlineCompletionProviderResult;
-        this.request = request;
-        this._textModel = _textModel;
-        this._versionId = _versionId;
-        this._refCount = 1;
-        this._prependedInlineCompletionItems = [];
-        this._inlineCompletions = ( inlineCompletionProviderResult.completions.map(completion => ( new InlineCompletionWithUpdatedRange(completion, undefined, this._textModel, this._versionId, this.request))));
-    }
-    clone() {
-        this._refCount++;
-        return this;
-    }
-    dispose() {
-        this._refCount--;
-        if (this._refCount === 0) {
-            this.inlineCompletionProviderResult.dispose();
-            for (const i of this._prependedInlineCompletionItems) {
-                i.source.removeRef();
-            }
-            this._inlineCompletions.forEach(i => i.dispose());
-        }
+class InlineCompletionsState extends Disposable {
+    static createEmpty() {
+        return ( new InlineCompletionsState([], undefined));
     }
-    prepend(inlineCompletion, range, addRefToSource) {
-        if (addRefToSource) {
-            inlineCompletion.source.addRef();
+    constructor(inlineCompletions, request) {
+        for (const inlineCompletion of inlineCompletions) {
+            inlineCompletion.addRef();
         }
-        this._inlineCompletions.unshift(( new InlineCompletionWithUpdatedRange(inlineCompletion, range, this._textModel, this._versionId, this.request)));
-        this._prependedInlineCompletionItems.push(inlineCompletion);
-    }
-}
-class InlineCompletionWithUpdatedRange extends Disposable {
-    get forwardStable() {
-        return this.source.inlineCompletions.enableForwardStability ?? false;
-    }
-    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.isInlineEdit; }
-    constructor(inlineCompletion, updatedRange, _textModel, _modelVersion, request) {
         super();
-        this.inlineCompletion = inlineCompletion;
-        this._textModel = _textModel;
-        this._modelVersion = _modelVersion;
+        this.inlineCompletions = inlineCompletions;
         this.request = request;
-        this.semanticId = JSON.stringify([
-            this.inlineCompletion.filterText,
-            this.inlineCompletion.insertText,
-            ( this.inlineCompletion.range.getStartPosition().toString())
-        ]);
-        this._updatedRange = derived(reader => {
-            const edit = this.updatedEdit.read(reader);
-            if (!edit || edit.edits.length === 0) {
-                return undefined;
-            }
-            return Range.fromPositions(this._textModel.getPositionAt(edit.edits[0].replaceRange.start), this._textModel.getPositionAt(edit.edits[edit.edits.length - 1].replaceRange.endExclusive));
-        });
-        this._updatedEditObj = this._register(this._toUpdatedEdit(updatedRange ?? this.inlineCompletion.range, this.inlineCompletion.insertText));
-    }
-    toInlineCompletion(reader) {
-        const singleTextEdit = this.toSingleTextEdit(reader);
-        return this.inlineCompletion.withRangeInsertTextAndFilterText(singleTextEdit.range, singleTextEdit.text, singleTextEdit.text);
-    }
-    toSingleTextEdit(reader) {
-        this._modelVersion.read(reader);
-        const offsetEdit = this.updatedEdit.read(reader);
-        if (!offsetEdit) {
-            return ( new SingleTextEdit(
-                this._updatedRange.read(reader) ?? emptyRange,
-                this.inlineCompletion.insertText
-            ));
-        }
-        const startOffset = offsetEdit.edits[0].replaceRange.start;
-        const endOffset = offsetEdit.edits[offsetEdit.edits.length - 1].replaceRange.endExclusive;
-        const overallOffsetRange = ( new OffsetRange(startOffset, endOffset));
-        const overallLnColRange = Range.fromPositions(this._textModel.getPositionAt(overallOffsetRange.start), this._textModel.getPositionAt(overallOffsetRange.endExclusive));
-        let text = this._textModel.getValueInRange(overallLnColRange);
-        for (let i = offsetEdit.edits.length - 1; i >= 0; i--) {
-            const edit = offsetEdit.edits[i];
-            const relativeStartOffset = edit.replaceRange.start - startOffset;
-            const relativeEndOffset = edit.replaceRange.endExclusive - startOffset;
-            text = text.substring(0, relativeStartOffset) + edit.newText + text.substring(relativeEndOffset);
-        }
-        return ( new SingleTextEdit(overallLnColRange, text));
-    }
-    isVisible(model, cursorPosition, reader) {
-        const minimizedReplacement = singleTextRemoveCommonPrefix(this.toSingleTextEdit(reader), model);
-        const updatedRange = this._updatedRange.read(reader);
-        if (!updatedRange
-            || !this.inlineCompletion.range.getStartPosition().equals(updatedRange.getStartPosition())
-            || cursorPosition.lineNumber !== minimizedReplacement.range.startLineNumber
-            || minimizedReplacement.isEmpty
-        ) {
-            return false;
-        }
-        const originalValue = model.getValueInRange(minimizedReplacement.range, EndOfLinePreference.LF);
-        const filterText = minimizedReplacement.text;
-        const cursorPosIndex = Math.max(0, cursorPosition.column - minimizedReplacement.range.startColumn);
-        let filterTextBefore = filterText.substring(0, cursorPosIndex);
-        let filterTextAfter = filterText.substring(cursorPosIndex);
-        let originalValueBefore = originalValue.substring(0, cursorPosIndex);
-        let originalValueAfter = originalValue.substring(cursorPosIndex);
-        const originalValueIndent = model.getLineIndentColumn(minimizedReplacement.range.startLineNumber);
-        if (minimizedReplacement.range.startColumn <= originalValueIndent) {
-            originalValueBefore = originalValueBefore.trimStart();
-            if (originalValueBefore.length === 0) {
-                originalValueAfter = originalValueAfter.trimStart();
-            }
-            filterTextBefore = filterTextBefore.trimStart();
-            if (filterTextBefore.length === 0) {
-                filterTextAfter = filterTextAfter.trimStart();
-            }
-        }
-        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._updatedEditObj.lastChangePartOfInlineEdit;
-        }
-        const updatedRange = this._updatedRange.read(undefined);
-        const result = !!updatedRange
-            && updatedRange.containsPosition(position)
-            && this.isVisible(model, position, undefined)
-            && TextLength.ofRange(updatedRange).isGreaterThanOrEqualTo(TextLength.ofRange(this.inlineCompletion.range));
-        return result;
-    }
-    _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) {
-        super();
-        this._textModel = _textModel;
-        this._modelVersion = _modelVersion;
-        this._lastChangePartOfInlineEdit = false;
-        this._updatedEdit = derivedHandleChanges({
-            owner: this,
-            equalityComparer: equalsIfDefined((a, b) => a?.equals(b)),
-            createEmptyChangeSummary: () => [],
-            handleChange: (context, changeSummary) => {
-                if (context.didChange(this._modelVersion) && context.change) {
-                    changeSummary.push(OffsetEdits.fromContentChanges(context.change.changes));
+        this._register({
+            dispose: () => {
+                for (const inlineCompletion of this.inlineCompletions) {
+                    inlineCompletion.removeRef();
                 }
-                return true;
             }
-        }, (reader, changeSummary) => {
-            this._modelVersion.read(reader);
-            for (const change of changeSummary) {
-                this._innerEdits = this._applyTextModelChanges(change, this._innerEdits);
-            }
-            if (this._innerEdits.length === 0) {
-                return undefined;
-            }
-            if (( this._innerEdits.some(e => e.edit === undefined))) {
-                throw ( new BugIndicatingError('UpdatedEdit: Invalid state'));
-            }
-            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(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));
-        }));
-        this._updatedEdit.recomputeInitiallyAndOnChange(this._store);
     }
-    _applyTextModelChanges(textModelChanges, edits) {
-        for (const innerEdit of edits) {
-            innerEdit.applyTextModelChanges(textModelChanges);
-        }
-        if (( edits.some(edit => edit.edit === undefined))) {
-            return [];
-        }
-        const currentModelVersion = this._modelVersion.get();
-        this._lastChangePartOfInlineEdit = ( edits.some(edit => edit.lastChangeUpdatedEdit));
-        if (this._lastChangePartOfInlineEdit) {
-            this._inlineEditModelVersion = currentModelVersion ?? -1;
-        }
-        if (currentModelVersion === null || this._inlineEditModelVersion + 20 < currentModelVersion) {
-            return [];
-        }
-        edits = edits.filter(innerEdit => !innerEdit.edit.isEmpty);
-        if (edits.length === 0) {
-            return [];
-        }
-        return edits;
+    _findById(id) {
+        return this.inlineCompletions.find(i => i.identity === id);
     }
-    reuse() {
-        this._inlineEditModelVersion = this._modelVersion.get() ?? -1;
+    _findByHash(hash) {
+        return this.inlineCompletions.find(i => i.hash === hash);
     }
-}
-class SingleUpdatedEdit {
-    get edit() { return this._edit; }
-    get lastChangeUpdatedEdit() { return this._lastChangeUpdatedEdit; }
-    constructor(edit) {
-        this._lastChangeUpdatedEdit = false;
-        this._edit = edit;
+    createStateWithAppliedEdit(edit, textModel) {
+        const newInlineCompletions = ( this.inlineCompletions.map(i => i.withEdit(edit, textModel))).filter(isDefined);
+        return ( new InlineCompletionsState(newInlineCompletions, this.request));
     }
-    applyTextModelChanges(textModelChanges) {
-        this._lastChangeUpdatedEdit = false;
-        if (!this._edit) {
-            throw ( new BugIndicatingError('UpdatedInnerEdits: No edit to apply changes to'));
-        }
-        const result = this.applyChanges(this._edit, textModelChanges);
-        if (!result) {
-            this._edit = undefined;
-            return;
-        }
-        this._edit = result.edit;
-        this._lastChangeUpdatedEdit = result.editHasChanged;
-    }
-}
-class SingleUpdatedCompletion extends SingleUpdatedEdit {
-    constructor(edit) {
-        super(edit);
-    }
-    applyChanges(edit, textModelChanges) {
-        const newEditRange = applyEditsToRanges([edit.replaceRange], textModelChanges)[0];
-        return { edit: ( new SingleOffsetEdit(newEditRange, edit.newText)), editHasChanged: !newEditRange.equals(edit.replaceRange) };
-    }
-}
-class SingleUpdatedNextEdit extends SingleUpdatedEdit {
-    constructor(edit, replacedText) {
-        super(edit);
-        this._prefixLength = commonPrefixLength(edit.newText, replacedText);
-        this._suffixLength = commonSuffixLength(edit.newText, replacedText);
-        this._trimmedNewText = edit.newText.substring(this._prefixLength, edit.newText.length - this._suffixLength);
-    }
-    applyChanges(edit, textModelChanges) {
-        let editStart = edit.replaceRange.start;
-        let editEnd = edit.replaceRange.endExclusive;
-        let editReplaceText = edit.newText;
-        let editHasChanged = false;
-        const shouldPreserveEditShape = this._prefixLength > 0 || this._suffixLength > 0;
-        for (let i = textModelChanges.edits.length - 1; i >= 0; i--) {
-            const change = textModelChanges.edits[i];
-            const isInsertion = change.newText.length > 0 && change.replaceRange.isEmpty;
-            if (isInsertion && !shouldPreserveEditShape && change.replaceRange.start === editStart && editReplaceText.startsWith(change.newText)) {
-                editStart += change.newText.length;
-                editReplaceText = editReplaceText.substring(change.newText.length);
-                editEnd = Math.max(editStart, editEnd);
-                editHasChanged = true;
-                continue;
-            }
-            if (isInsertion && shouldPreserveEditShape && change.replaceRange.start === editStart + this._prefixLength && this._trimmedNewText.startsWith(change.newText)) {
-                editEnd += change.newText.length;
-                editHasChanged = true;
-                this._prefixLength += change.newText.length;
-                this._trimmedNewText = this._trimmedNewText.substring(change.newText.length);
-                continue;
-            }
-            const isDeletion = change.newText.length === 0 && change.replaceRange.length > 0;
-            if (isDeletion && change.replaceRange.start >= editStart + this._prefixLength && change.replaceRange.endExclusive <= editEnd - this._suffixLength) {
-                editEnd -= change.replaceRange.length;
-                editHasChanged = true;
-                continue;
+    createStateWithAppliedResults(update, request, textModel, itemToPreserve) {
+        const items = [];
+        for (const item of update.completions) {
+            const i = InlineSuggestionItem.create(item, textModel);
+            const oldItem = this._findByHash(i.hash);
+            if (oldItem) {
+                items.push(i.withIdentity(oldItem.identity));
+                oldItem.setEndOfLifeReason({ kind: InlineCompletionEndOfLifeReasonKind.Ignored, userTypingDisagreed: false, supersededBy: i.getSourceCompletion() });
             }
-            if (change.equals(edit)) {
-                editHasChanged = true;
-                editStart = change.replaceRange.endExclusive;
-                editReplaceText = '';
-                continue;
+            else {
+                items.push(i);
             }
-            if (change.replaceRange.start > editEnd) {
-                continue;
-            }
-            if (change.replaceRange.endExclusive < editStart) {
-                editStart += change.newText.length - change.replaceRange.length;
-                editEnd += change.newText.length - change.replaceRange.length;
-                continue;
-            }
-            return undefined;
         }
-        if (this._trimmedNewText.length === 0 && editStart + this._prefixLength === editEnd - this._suffixLength) {
-            return { edit: ( new SingleOffsetEdit(( new OffsetRange(editStart + this._prefixLength, editStart + this._prefixLength)), '')), editHasChanged: true };
-        }
-        return { edit: ( new SingleOffsetEdit(( new OffsetRange(editStart, editEnd)), editReplaceText)), editHasChanged };
-    }
-}
-const emptyRange = ( new Range(1, 1, 1, 1));
-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), ''));
+        if (itemToPreserve) {
+            const item = this._findById(itemToPreserve);
+            if (item && !( update.has(item.getSingleTextEdit())) && item.canBeReused(textModel, request.position)) {
+                items.unshift(item);
+            }
         }
+        return ( new InlineCompletionsState(items, request));
     }
-    return edit;
-}
-function reshapeMultiLineInsertion(edit, textModel) {
-    if (!edit.replaceRange.isEmpty) {
-        throw ( new BugIndicatingError('Unexpected original range'));
-    }
-    if (edit.replaceRange.start === 0) {
-        return edit;
-    }
-    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)));
+    clone() {
+        return ( new InlineCompletionsState(this.inlineCompletions, this.request));
     }
-    return edit;
 }
 
-export { InlineCompletionWithUpdatedRange, InlineCompletionsSource, UpToDateInlineCompletions };
+export { InlineCompletionsSource };