@codingame/monaco-vscode-api 16.1.1 → 17.1.0

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

@@ -22,26 +22,28 @@ import { Selection } from '../../../../common/core/selection.js';
 import { TextEdit, SingleTextEdit } from '../../../../common/core/textEdit.js';
 import { TextLength } from '../../../../common/core/textLength.js';
 import { ScrollType } from '../../../../common/editorCommon.js';
-import { InlineCompletionTriggerKind, PartialAcceptTriggerKind } from '../../../../common/languages.js';
+import { InlineCompletionTriggerKind, InlineCompletionEndOfLifeReasonKind, PartialAcceptTriggerKind } from '../../../../common/languages.js';
 import { ILanguageConfigurationService } from '../../../../common/languages/languageConfigurationRegistry.service.js';
 import { EndOfLinePreference } from '../../../../common/model.js';
 import { TextModelText } from '../../../../common/model/textModelText.js';
+import { ILanguageFeaturesService } from '../../../../common/services/languageFeatures.service.js';
 import { SnippetController2 } from '../../../snippet/browser/snippetController2.js';
-import { getEndPositionsAfterApplying, getModifiedRangesAfterApplying, subtractPositions, substringPos, addPositions } from '../utils.js';
+import { getEndPositionsAfterApplying, subtractPositions, substringPos, addPositions } from '../utils.js';
 import { AnimatedValue, easeOutCubic, ObservableAnimatedValue } from './animation.js';
+import { TextModelChangeRecorder } from './changeRecorder.js';
 import { computeGhostText } from './computeGhostText.js';
 import { ghostTextsOrReplacementsEqual, GhostText, ghostTextOrReplacementEquals } from './ghostText.js';
 import { InlineCompletionsSource } from './inlineCompletionsSource.js';
 import { InlineEdit } from './inlineEdit.js';
 import { singleTextRemoveCommonPrefix, singleTextEditAugments } from './singleTextEditHelpers.js';
-import { observableValue, transaction, subtransaction } from '../../../../../base/common/observableInternal/base.js';
-import { observableSignal, recomputeInitiallyAndOnChange, constObservable } from '../../../../../base/common/observableInternal/utils.js';
 import { derived, derivedHandleChanges, derivedOpts } from '../../../../../base/common/observableInternal/derived.js';
-import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
+import { observableValue, transaction, subtransaction } from '../../../../../base/common/observableInternal/base.js';
+import { observableSignal, recomputeInitiallyAndOnChange, observableFromEvent, constObservable } from '../../../../../base/common/observableInternal/utils.js';
+import { autorun, autorunWithStore } from '../../../../../base/common/observableInternal/autorun.js';
 
 let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
     get isAcceptingPartially() { return this._isAcceptingPartially; }
-    constructor(textModel, _selectedSuggestItem, _textModelVersionId, _positions, _debounceValue, _enabled, _editor, _instantiationService, _commandService, _languageConfigurationService, _accessibilityService) {
+    constructor(textModel, _selectedSuggestItem, _textModelVersionId, _positions, _debounceValue, _enabled, _editor, _instantiationService, _commandService, _languageConfigurationService, _accessibilityService, _languageFeaturesService) {
         super();
         this.textModel = textModel;
         this._selectedSuggestItem = _selectedSuggestItem;
@@ -54,11 +56,13 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         this._commandService = _commandService;
         this._languageConfigurationService = _languageConfigurationService;
         this._accessibilityService = _accessibilityService;
+        this._languageFeaturesService = _languageFeaturesService;
         this._source = this._register(this._instantiationService.createInstance(InlineCompletionsSource, this.textModel, this._textModelVersionId, this._debounceValue));
         this._isActive = observableValue(this, false);
         this._onlyRequestInlineEditsSignal = observableSignal(this);
         this._forceUpdateExplicitlySignal = observableSignal(this);
         this._noDelaySignal = observableSignal(this);
+        this._fetchSpecificProviderSignal = observableSignal(this);
         this._selectedInlineCompletionId = observableValue(this, undefined);
         this.primaryPosition = derived(this, reader => this._positions.read(reader)[0] ?? ( new Position(1, 1)));
         this._isAcceptingPartially = false;
@@ -74,10 +78,12 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         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;
+            changeTracker: {
+                createChangeSummary: () => ({ didUndo: false }),
+                handleChange: (ctx, changeSummary) => {
+                    changeSummary.didUndo = ctx.didChange(this._textModelVersionId) && !!ctx.change?.isUndoing;
+                    return true;
+                }
             }
         }, (reader, changeSummary) => {
             const versionId = this._textModelVersionId.read(reader);
@@ -99,30 +105,33 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         this.dontRefetchSignal = observableSignal(this);
         this._fetchInlineCompletionsPromise = derivedHandleChanges({
             owner: this,
-            createEmptyChangeSummary: () => ({
-                dontRefetch: false,
-                preserveCurrentCompletion: false,
-                inlineCompletionTriggerKind: InlineCompletionTriggerKind.Automatic,
-                onlyRequestInlineEdits: false,
-                shouldDebounce: true,
-            }),
-            handleChange: (ctx, changeSummary) => {
-                if (ctx.didChange(this._textModelVersionId) && ( this._preserveCurrentCompletionReasons.has(this._getReason(ctx.change)))) {
-                    changeSummary.preserveCurrentCompletion = true;
-                }
-                else if (ctx.didChange(this._forceUpdateExplicitlySignal)) {
-                    changeSummary.inlineCompletionTriggerKind = InlineCompletionTriggerKind.Explicit;
-                }
-                else if (ctx.didChange(this.dontRefetchSignal)) {
-                    changeSummary.dontRefetch = true;
-                }
-                else if (ctx.didChange(this._onlyRequestInlineEditsSignal)) {
-                    changeSummary.onlyRequestInlineEdits = true;
-                }
-                else if (ctx.didChange(this._noDelaySignal)) {
-                    changeSummary.shouldDebounce = false;
-                }
-                return true;
+            changeTracker: {
+                createChangeSummary: () => ({
+                    dontRefetch: false,
+                    preserveCurrentCompletion: false,
+                    inlineCompletionTriggerKind: InlineCompletionTriggerKind.Automatic,
+                    onlyRequestInlineEdits: false,
+                    shouldDebounce: true,
+                    provider: undefined,
+                }),
+                handleChange: (ctx, changeSummary) => {
+                    if (ctx.didChange(this._textModelVersionId) && ( this._preserveCurrentCompletionReasons.has(this._getReason(ctx.change)))) {
+                        changeSummary.preserveCurrentCompletion = true;
+                    }
+                    else if (ctx.didChange(this._forceUpdateExplicitlySignal)) {
+                        changeSummary.inlineCompletionTriggerKind = InlineCompletionTriggerKind.Explicit;
+                    }
+                    else if (ctx.didChange(this.dontRefetchSignal)) {
+                        changeSummary.dontRefetch = true;
+                    }
+                    else if (ctx.didChange(this._onlyRequestInlineEditsSignal)) {
+                        changeSummary.onlyRequestInlineEdits = true;
+                    }
+                    else if (ctx.didChange(this._fetchSpecificProviderSignal)) {
+                        changeSummary.provider = ctx.change;
+                    }
+                    return true;
+                },
             },
         }, (reader, changeSummary) => {
             this._source.clearOperationOnTextModelChange.read(reader);
@@ -130,6 +139,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             this.dontRefetchSignal.read(reader);
             this._onlyRequestInlineEditsSignal.read(reader);
             this._forceUpdateExplicitlySignal.read(reader);
+            this._fetchSpecificProviderSignal.read(reader);
             const shouldUpdate = (this._enabled.read(reader) && this._selectedSuggestItem.read(reader)) || this._isActive.read(reader);
             if (!shouldUpdate) {
                 this._source.cancelUpdate();
@@ -139,19 +149,13 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             const suggestWidgetInlineCompletions = this._source.suggestWidgetInlineCompletions.get();
             const suggestItem = this._selectedSuggestItem.read(reader);
             if (suggestWidgetInlineCompletions && !suggestItem) {
-                const inlineCompletions = this._source.inlineCompletions.get();
-                transaction(tx => {
-                    if (!inlineCompletions || suggestWidgetInlineCompletions.request.versionId > inlineCompletions.request.versionId) {
-                        this._source.inlineCompletions.set(suggestWidgetInlineCompletions.clone(), tx);
-                    }
-                    this._source.clearSuggestWidgetInlineCompletions(tx);
-                });
+                this._source.seedInlineCompletionsWithSuggestWidget();
             }
             const cursorPosition = this.primaryPosition.get();
             if (changeSummary.dontRefetch) {
                 return Promise.resolve(true);
             }
-            if (this._didUndoInlineEdits.read(reader)) {
+            if (this._didUndoInlineEdits.read(reader) && changeSummary.inlineCompletionTriggerKind !== InlineCompletionTriggerKind.Explicit) {
                 transaction(tx => {
                     this._source.clear(tx);
                 });
@@ -178,7 +182,8 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             const userJumpedToActiveCompletion = ( this._jumpedToId.map(
                 jumpedTo => !!jumpedTo && jumpedTo === this._inlineCompletionItems.get()?.inlineEdit?.semanticId
             ));
-            return this._source.fetch(cursorPosition, context, itemToPreserve, changeSummary.shouldDebounce, userJumpedToActiveCompletion);
+            const providers = changeSummary.provider ? [changeSummary.provider] : this._languageFeaturesService.inlineCompletionsProvider.all(this.textModel);
+            return this._source.fetch(providers, cursorPosition, context, itemToPreserve?.identity, changeSummary.shouldDebounce, userJumpedToActiveCompletion, !!changeSummary.provider);
         });
         this._inlineCompletionItems = derivedOpts({ owner: this }, reader => {
             const c = this._source.inlineCompletions.read(reader);
@@ -189,8 +194,8 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             let inlineEdit = undefined;
             const visibleCompletions = [];
             for (const completion of c.inlineCompletions) {
-                if (!completion.sourceInlineCompletion.isInlineEdit) {
-                    if (completion.isVisible(this.textModel, cursorPosition, reader)) {
+                if (!completion.isInlineEdit) {
+                    if (completion.isVisible(this.textModel, cursorPosition)) {
                         visibleCompletions.push(completion);
                     }
                 }
@@ -226,8 +231,8 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             const idx = this.selectedInlineCompletionIndex.read(reader);
             return filteredCompletions[idx];
         });
-        this.activeCommands = derivedOpts({ owner: this, equalsFn: itemsEquals() }, r => this.selectedInlineCompletion.read(r)?.source.inlineCompletions.commands ?? []);
-        this.lastTriggerKind = ( this._source.inlineCompletions.map(this, v => v?.request.context.triggerKind));
+        this.activeCommands = derivedOpts({ owner: this, equalsFn: itemsEquals() }, r => this.selectedInlineCompletion.read(r)?.source.inlineSuggestions.commands ?? []);
+        this.lastTriggerKind = ( this._source.inlineCompletions.map(this, v => v?.request?.context.triggerKind));
         this.inlineCompletionsCount = derived(this, reader => {
             if (this.lastTriggerKind.read(reader) === InlineCompletionTriggerKind.Explicit) {
                 return this._filteredInlineCompletionItems.read(reader).length;
@@ -249,7 +254,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                         && a.suggestItem === b.suggestItem;
                 }
                 else if (a.kind === 'inlineEdit' && b.kind === 'inlineEdit') {
-                    return a.inlineEdit.equals(b.inlineEdit) && a.cursorAtInlineEdit === b.cursorAtInlineEdit;
+                    return a.inlineEdit.equals(b.inlineEdit);
                 }
                 return false;
             }
@@ -261,23 +266,20 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 if (this._hasVisiblePeekWidgets.read(reader)) {
                     return undefined;
                 }
-                let edit = inlineEditResult.toSingleTextEdit(reader);
+                let edit = inlineEditResult.getSingleTextEdit();
                 edit = singleTextRemoveCommonPrefix(edit, model);
-                const cursorPos = this.primaryPosition.read(reader);
-                const cursorAtInlineEdit = LineRange.fromRangeInclusive(edit.range).addMargin(1, 1).contains(cursorPos.lineNumber);
-                const cursorInsideShowRange = cursorAtInlineEdit || (inlineEditResult.inlineCompletion.cursorShowRange?.containsPosition(cursorPos) ?? true);
-                if (!cursorInsideShowRange && !this._inAcceptFlow.read(reader)) {
-                    return undefined;
-                }
-                const commands = inlineEditResult.inlineCompletion.source.inlineCompletions.commands;
-                const inlineEdit = ( new InlineEdit(edit, commands ?? [], inlineEditResult.inlineCompletion));
-                const edits = inlineEditResult.updatedEdit.read(reader);
+                const cursorAtInlineEdit = ( this.primaryPosition.map(
+                    cursorPos => LineRange.fromRangeInclusive(inlineEditResult.targetRange).addMargin(1, 1).contains(cursorPos.lineNumber)
+                ));
+                const commands = inlineEditResult.source.inlineSuggestions.commands;
+                const inlineEdit = ( new InlineEdit(edit, commands ?? [], inlineEditResult));
+                const edits = inlineEditResult.updatedEdit;
                 const e = edits ? TextEdit.fromOffsetEdit(edits, ( new TextModelText(this.textModel))).edits : [edit];
                 return { kind: 'inlineEdit', inlineEdit, inlineCompletion: inlineEditResult, edits: e, cursorAtInlineEdit };
             }
             const suggestItem = this._selectedSuggestItem.read(reader);
             if (suggestItem) {
-                const suggestCompletionEdit = singleTextRemoveCommonPrefix(suggestItem.toSingleTextEdit(), model);
+                const suggestCompletionEdit = singleTextRemoveCommonPrefix(suggestItem.getSingleTextEdit(), model);
                 const augmentation = this._computeAugmentation(suggestCompletionEdit, reader);
                 const isSuggestionPreviewEnabled = this._suggestPreviewEnabled.read(reader);
                 if (!isSuggestionPreviewEnabled && !augmentation) {
@@ -304,7 +306,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 if (!inlineCompletion) {
                     return undefined;
                 }
-                const replacement = inlineCompletion.toSingleTextEdit(reader);
+                const replacement = inlineCompletion.getSingleTextEdit();
                 const mode = this._inlineSuggestMode.read(reader);
                 const positions = this._positions.read(reader);
                 const edits = [replacement, ...getSecondaryEdits(this.textModel, positions, replacement)];
@@ -352,7 +354,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             return !!s;
         });
         this.warning = derived(this, reader => {
-            return this.inlineCompletionState.read(reader)?.inlineCompletion?.sourceInlineCompletion.warning;
+            return this.inlineCompletionState.read(reader)?.inlineCompletion?.warning;
         });
         this.ghostTexts = derivedOpts({ owner: this, equalsFn: ghostTextsOrReplacementsEqual }, reader => {
             const v = this.inlineCompletionState.read(reader);
@@ -373,6 +375,9 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (!state || state.kind !== 'inlineEdit') {
                 return false;
             }
+            if (state.inlineCompletion.displayLocation) {
+                return false;
+            }
             const isCurrentModelVersion = state.inlineCompletion.updatedEditModelVersion === this._textModelVersionId.read(reader);
             return (this._inlineEditsShowCollapsedEnabled.read(reader) || !isCurrentModelVersion)
                 && this._jumpedToId.read(reader) !== state.inlineCompletion.semanticId
@@ -412,7 +417,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (this.showCollapsed.read(reader)) {
                 return true;
             }
-            return !s.cursorAtInlineEdit;
+            return !s.cursorAtInlineEdit.read(reader);
         });
         this.tabShouldAcceptInlineEdit = derived(this, reader => {
             const s = this.inlineEditState.read(reader);
@@ -422,7 +427,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (this.showCollapsed.read(reader)) {
                 return false;
             }
-            if (s.inlineEdit.range.startLineNumber === this._editorObs.cursorLineNumber.read(reader)) {
+            if (s.inlineCompletion.targetRange.startLineNumber === this._editorObs.cursorLineNumber.read(reader)) {
                 return true;
             }
             if (this._jumpedToId.read(reader) === s.inlineCompletion.semanticId) {
@@ -431,37 +436,17 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (this._tabShouldIndent.read(reader)) {
                 return false;
             }
-            return s.cursorAtInlineEdit;
+            return s.cursorAtInlineEdit.read(reader);
         });
-        this._inAcceptPartialFlow = 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));
-        let lastItem = undefined;
         this._register(autorun(reader => {
             const item = this.inlineCompletionState.read(reader);
             const completion = item?.inlineCompletion;
-            if (completion?.semanticId !== lastItem?.semanticId) {
-                lastItem = completion;
-                if (completion) {
-                    const i = completion.inlineCompletion;
-                    const src = i.source;
-                    src.provider.handleItemDidShow?.(src.inlineCompletions, i.sourceInlineCompletion, i.insertText);
-                }
-            }
-        }));
-        this._register(autorun(reader => {
-            const inlineCompletions = this._source.inlineCompletions.read(reader);
-            if (!inlineCompletions) {
-                return;
-            }
-            for (const inlineCompletion of inlineCompletions.inlineCompletions) {
-                if (inlineCompletion.updatedEdit.read(reader) === undefined) {
-                    this.stop();
-                    break;
-                }
+            if (completion) {
+                this.handleInlineSuggestionShown(completion);
             }
         }));
         this._register(autorun(reader => {
@@ -469,7 +454,9 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             this._inAcceptFlow.set(false, undefined);
         }));
         this._register(autorun(reader => {
-            const jumpToReset = ( this.state.map(s => !s || s.kind === 'inlineEdit' && !s.cursorAtInlineEdit)).read(reader);
+            const jumpToReset = ( this.state.map(
+                (s, reader) => !s || s.kind === 'inlineEdit' && !s.cursorAtInlineEdit.read(reader)
+            )).read(reader);
             if (jumpToReset) {
                 this._jumpedToId.set(undefined, undefined);
             }
@@ -481,10 +468,32 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 this._editor.pushUndoStop();
                 this._lastShownInlineCompletionInfo = {
                     alternateTextModelVersionId: this.textModel.getAlternativeVersionId(),
-                    inlineCompletion: this.state.get().inlineCompletion.inlineCompletion,
+                    inlineCompletion: this.state.get().inlineCompletion,
                 };
             }
         }));
+        const inlineCompletionProviders = observableFromEvent(this._languageFeaturesService.inlineCompletionsProvider.onDidChange, () => this._languageFeaturesService.inlineCompletionsProvider.all(textModel));
+        this._register(autorunWithStore((reader, store) => {
+            const providers = inlineCompletionProviders.read(reader);
+            for (const provider of providers) {
+                if (!provider.onDidChangeInlineCompletions) {
+                    continue;
+                }
+                store.add(provider.onDidChangeInlineCompletions(() => {
+                    if (!this._enabled.get()) {
+                        return;
+                    }
+                    const activeState = this.state.get();
+                    if (activeState && (activeState.inlineCompletion || activeState.edits) && activeState.inlineCompletion?.source.provider !== provider) {
+                        return;
+                    }
+                    transaction(tx => {
+                        this._fetchSpecificProviderSignal.trigger(tx, provider);
+                        this.trigger(tx);
+                    });
+                }));
+            }
+        }));
         this._didUndoInlineEdits.recomputeInitiallyAndOnChange(this._store);
     }
     debugGetSelectedSuggestItem() {
@@ -554,13 +563,10 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         subtransaction(tx, tx => {
             if (stopReason === 'explicitCancel') {
                 const inlineCompletion = this.state.get()?.inlineCompletion;
-                const source = inlineCompletion?.source;
-                const sourceInlineCompletion = inlineCompletion?.sourceInlineCompletion;
-                if (sourceInlineCompletion && source?.provider.handleRejection) {
-                    source.provider.handleRejection(source.inlineCompletions, sourceInlineCompletion);
+                if (inlineCompletion) {
+                    inlineCompletion.reportEndOfLife({ kind: InlineCompletionEndOfLifeReasonKind.Rejected });
                 }
             }
-            this._inAcceptPartialFlow.set(false, tx);
             this._isActive.set(false, tx);
             this._source.clear(tx);
         });
@@ -569,10 +575,10 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         const model = this.textModel;
         const suggestWidgetInlineCompletions = this._source.suggestWidgetInlineCompletions.read(reader);
         const candidateInlineCompletions = suggestWidgetInlineCompletions
-            ? suggestWidgetInlineCompletions.inlineCompletions
+            ? suggestWidgetInlineCompletions.inlineCompletions.filter(c => !c.isInlineEdit)
             : [this.selectedInlineCompletion.read(reader)].filter(isDefined);
         const augmentedCompletion = mapFindFirst(candidateInlineCompletions, completion => {
-            let r = completion.toSingleTextEdit(reader);
+            let r = completion.getSingleTextEdit();
             r = singleTextRemoveCommonPrefix(r, model, Range.fromPositions(r.range.getStartPosition(), suggestCompletion.range.getEndPosition()));
             return singleTextEditAugments(r, suggestCompletion) ? { completion, edit: r } : undefined;
         });
@@ -591,50 +597,58 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
     }
     async next() { await this._deltaSelectedInlineCompletionIndex(1); }
     async previous() { await this._deltaSelectedInlineCompletionIndex(-1); }
+    _getMetadata(completion, type = undefined) {
+        return {
+            extensionId: completion.source.provider.groupId,
+            nes: completion.isInlineEdit,
+            type
+        };
+    }
     async accept(editor = this._editor) {
         if (editor.getModel() !== this.textModel) {
             throw ( new BugIndicatingError());
         }
-        if (this._inAcceptPartialFlow.get()) {
-            this._inAcceptPartialFlow.set(false, undefined);
-            this.jump();
-            return;
-        }
-        let completionWithUpdatedRange;
+        let completion;
         const state = this.state.get();
         if (state?.kind === 'ghostText') {
             if (!state || state.primaryGhostText.isEmpty() || !state.inlineCompletion) {
                 return;
             }
-            completionWithUpdatedRange = state.inlineCompletion;
+            completion = state.inlineCompletion;
         }
         else if (state?.kind === 'inlineEdit') {
-            completionWithUpdatedRange = state.inlineCompletion;
+            completion = state.inlineCompletion;
         }
         else {
             return;
         }
-        const completion = completionWithUpdatedRange.toInlineCompletion(undefined);
+        completion.reportEndOfLife({ kind: InlineCompletionEndOfLifeReasonKind.Accepted });
         if (completion.command) {
             completion.source.addRef();
         }
         editor.pushUndoStop();
         if (completion.snippetInfo) {
-            editor.executeEdits('inlineSuggestion.accept', [
-                EditOperation.replace(completion.range, ''),
-                ...completion.additionalTextEdits
-            ]);
+            TextModelChangeRecorder.editWithMetadata(this._getMetadata(completion), () => {
+                editor.executeEdits('inlineSuggestion.accept', [
+                    EditOperation.replace(completion.editRange, ''),
+                    ...completion.additionalTextEdits
+                ]);
+            });
             editor.setPosition(completion.snippetInfo.range.getStartPosition(), 'inlineCompletionAccept');
             SnippetController2.get(editor)?.insert(completion.snippetInfo.snippet, { undoStopBefore: false });
         }
         else {
             const edits = state.edits;
             const selections = ( getEndPositionsAfterApplying(edits).map(p => Selection.fromPositions(p)));
-            editor.executeEdits('inlineSuggestion.accept', [
-                ...( edits.map(edit => EditOperation.replace(edit.range, edit.text))),
-                ...completion.additionalTextEdits
-            ]);
-            editor.setSelections(state.kind === 'inlineEdit' ? selections.slice(-1) : selections, 'inlineCompletionAccept');
+            TextModelChangeRecorder.editWithMetadata(this._getMetadata(completion), () => {
+                editor.executeEdits('inlineSuggestion.accept', [
+                    ...( edits.map(edit => EditOperation.replace(edit.range, edit.text))),
+                    ...completion.additionalTextEdits
+                ]);
+            });
+            if (completion.displayLocation === undefined) {
+                editor.setSelections(state.kind === 'inlineEdit' ? selections.slice(-1) : selections, 'inlineCompletionAccept');
+            }
             if (state.kind === 'inlineEdit' && !this._accessibilityService.isMotionReduced()) {
                 const editRanges = ( new TextEdit(edits)).getNewRanges();
                 const dec = this._store.add(( new FadeoutDecoration(editor, editRanges, () => {
@@ -653,8 +667,8 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         this._inAcceptFlow.set(true, undefined);
         this._lastAcceptedInlineCompletionInfo = { textModelVersionIdAfter: this.textModel.getVersionId(), inlineCompletion: completion };
     }
-    async acceptNextWord(editor) {
-        await this._acceptNext(editor, (pos, text) => {
+    async acceptNextWord() {
+        await this._acceptNext(this._editor, 'word', (pos, text) => {
             const langId = this.textModel.getLanguageIdAtPosition(pos.lineNumber, pos.column);
             const config = this._languageConfigurationService.getLanguageConfiguration(langId);
             const wordRegExp = ( new RegExp(config.wordDefinition.source, config.wordDefinition.flags.replace('g', '')));
@@ -681,8 +695,8 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             return acceptUntilIndexExclusive;
         }, PartialAcceptTriggerKind.Word);
     }
-    async acceptNextLine(editor) {
-        await this._acceptNext(editor, (pos, text) => {
+    async acceptNextLine() {
+        await this._acceptNext(this._editor, 'line', (pos, text) => {
             const m = text.match(/\n/);
             if (m && m.index !== undefined) {
                 return m.index + 1;
@@ -690,7 +704,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             return text.length;
         }, PartialAcceptTriggerKind.Line);
     }
-    async _acceptNext(editor, getAcceptUntilIndex, kind) {
+    async _acceptNext(editor, type, getAcceptUntilIndex, kind) {
         if (editor.getModel() !== this.textModel) {
             throw ( new BugIndicatingError());
         }
@@ -699,8 +713,8 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             return;
         }
         const ghostText = state.primaryGhostText;
-        const completion = state.inlineCompletion.toInlineCompletion(undefined);
-        if (completion.snippetInfo || completion.filterText !== completion.insertText) {
+        const completion = state.inlineCompletion;
+        if (completion.snippetInfo) {
             await this.accept(editor);
             return;
         }
@@ -725,98 +739,43 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 const primaryEdit = ( new SingleTextEdit(replaceRange, newText));
                 const edits = [primaryEdit, ...getSecondaryEdits(this.textModel, positions, primaryEdit)];
                 const selections = ( getEndPositionsAfterApplying(edits).map(p => Selection.fromPositions(p)));
-                editor.executeEdits('inlineSuggestion.accept', ( edits.map(edit => EditOperation.replace(edit.range, edit.text))));
-                editor.setSelections(selections, 'inlineCompletionPartialAccept');
-                editor.revealPositionInCenterIfOutsideViewport(editor.getPosition(), ScrollType.Immediate);
-            }
-            finally {
-                this._isAcceptingPartially = false;
-            }
-            if (completion.source.provider.handlePartialAccept) {
-                const acceptedRange = Range.fromPositions(completion.range.getStartPosition(), TextLength.ofText(partialGhostTextVal).addToPosition(ghostTextPos));
-                const text = editor.getModel().getValueInRange(acceptedRange, EndOfLinePreference.LF);
-                const acceptedLength = text.length;
-                completion.source.provider.handlePartialAccept(completion.source.inlineCompletions, completion.sourceInlineCompletion, acceptedLength, { kind, acceptedLength: acceptedLength, });
-            }
-        }
-        finally {
-            completion.source.removeRef();
-        }
-    }
-    async acceptNextInlineEditPart(editor) {
-        if (editor.getModel() !== this.textModel) {
-            throw ( new BugIndicatingError());
-        }
-        const state = this.inlineEditState.get();
-        const updatedEdit = state?.inlineCompletion.updatedEdit.get();
-        const completion = state?.inlineCompletion.toInlineCompletion(undefined);
-        if (!updatedEdit || updatedEdit.isEmpty || !completion) {
-            return;
-        }
-        const nextPart = updatedEdit.edits[0];
-        const edit = ( new SingleTextEdit(
-            Range.fromPositions(this.textModel.getPositionAt(nextPart.replaceRange.start), this.textModel.getPositionAt(nextPart.replaceRange.endExclusive)),
-            nextPart.newText
-        ));
-        const cursorAtStartPosition = this._editor.getSelection()?.getStartPosition().equals(edit.range.getStartPosition());
-        if (!cursorAtStartPosition || !this._inAcceptPartialFlow.get()) {
-            this._inAcceptPartialFlow.set(true, undefined);
-            this.jump();
-            return;
-        }
-        const partToJumpToNext = updatedEdit.edits[1] ?? undefined;
-        const editToJumpToNext = partToJumpToNext ? ( new SingleTextEdit(
-            Range.fromPositions(this.textModel.getPositionAt(partToJumpToNext.replaceRange.start), this.textModel.getPositionAt(partToJumpToNext.replaceRange.endExclusive)),
-            partToJumpToNext.newText
-        )) : undefined;
-        completion.source.addRef();
-        try {
-            this._isAcceptingPartially = true;
-            try {
-                editor.pushUndoStop();
-                let selections;
-                if (editToJumpToNext) {
-                    const [_, rangeOfEditToJumpTo] = getModifiedRangesAfterApplying([edit, editToJumpToNext]);
-                    selections = [Selection.fromPositions(rangeOfEditToJumpTo.getStartPosition())];
-                }
-                else {
-                    selections = ( getEndPositionsAfterApplying([edit]).map(p => Selection.fromPositions(p)));
-                }
-                const edits = [edit];
-                editor.executeEdits('inlineSuggestion.accept', ( edits.map(edit => EditOperation.replace(edit.range, edit.text))));
+                TextModelChangeRecorder.editWithMetadata(this._getMetadata(completion, type), () => {
+                    editor.executeEdits('inlineSuggestion.accept', ( edits.map(edit => EditOperation.replace(edit.range, edit.text))));
+                });
                 editor.setSelections(selections, 'inlineCompletionPartialAccept');
                 editor.revealPositionInCenterIfOutsideViewport(editor.getPosition(), ScrollType.Immediate);
             }
             finally {
                 this._isAcceptingPartially = false;
             }
+            const acceptedRange = Range.fromPositions(completion.editRange.getStartPosition(), TextLength.ofText(partialGhostTextVal).addToPosition(ghostTextPos));
+            const text = editor.getModel().getValueInRange(acceptedRange, EndOfLinePreference.LF);
+            const acceptedLength = text.length;
+            completion.reportPartialAccept(acceptedLength, { kind, acceptedLength: acceptedLength });
         }
         finally {
             completion.source.removeRef();
         }
     }
     handleSuggestAccepted(item) {
-        const itemEdit = singleTextRemoveCommonPrefix(item.toSingleTextEdit(), this.textModel);
+        const itemEdit = singleTextRemoveCommonPrefix(item.getSingleTextEdit(), this.textModel);
         const augmentedCompletion = this._computeAugmentation(itemEdit, undefined);
         if (!augmentedCompletion) {
             return;
         }
-        const source = augmentedCompletion.completion.source;
-        const sourceInlineCompletion = augmentedCompletion.completion.sourceInlineCompletion;
-        const completion = augmentedCompletion.completion.toInlineCompletion(undefined);
-        const alreadyAcceptedLength = this.textModel.getValueInRange(completion.range, EndOfLinePreference.LF).length;
+        const alreadyAcceptedLength = this.textModel.getValueInRange(augmentedCompletion.completion.editRange, EndOfLinePreference.LF).length;
         const acceptedLength = alreadyAcceptedLength + itemEdit.text.length;
-        source.provider.handlePartialAccept?.(source.inlineCompletions, sourceInlineCompletion, itemEdit.text.length, {
+        augmentedCompletion.completion.reportPartialAccept(itemEdit.text.length, {
             kind: PartialAcceptTriggerKind.Suggest,
             acceptedLength,
         });
     }
     extractReproSample() {
         const value = this.textModel.getValue();
-        const item = this.state.get()?.inlineCompletion?.toInlineCompletion(undefined);
+        const item = this.state.get()?.inlineCompletion;
         return {
             documentValue: value,
-            inlineCompletion: item?.sourceInlineCompletion,
+            inlineCompletion: item?.getSourceCompletion(),
         };
     }
     jump() {
@@ -827,35 +786,30 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         transaction(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');
-            const isSingleLineChange = edit.range.startLineNumber === edit.range.endLineNumber && !edit.text.includes('\n');
+            const targetRange = s.inlineCompletion.targetRange;
+            const targetPosition = targetRange.getStartPosition();
+            this._editor.setPosition(targetPosition, 'inlineCompletions.jump');
+            const isSingleLineChange = targetRange.isSingleLine() && (s.inlineCompletion.displayLocation || !s.inlineCompletion.insertText.includes('\n'));
             if (isSingleLineChange) {
-                this._editor.revealPosition(edit.range.getStartPosition());
+                this._editor.revealPosition(targetPosition);
             }
             else {
-                const revealRange = ( new Range(edit.range.startLineNumber - 1, 1, edit.range.endLineNumber + 1, 1));
+                const revealRange = ( new Range(targetRange.startLineNumber - 1, 1, targetRange.endLineNumber + 1, 1));
                 this._editor.revealRange(revealRange, ScrollType.Immediate);
             }
             this._editor.focus();
         });
     }
-    async handleInlineEditShown(inlineCompletion) {
-        if (inlineCompletion.didShow) {
-            return;
-        }
-        inlineCompletion.markAsShown();
-        inlineCompletion.source.provider.handleItemDidShow?.(inlineCompletion.source.inlineCompletions, inlineCompletion.sourceInlineCompletion, inlineCompletion.insertText);
-        if (inlineCompletion.shownCommand) {
-            await this._commandService.executeCommand(inlineCompletion.shownCommand.id, ...(inlineCompletion.shownCommand.arguments || []));
-        }
+    async handleInlineSuggestionShown(inlineCompletion) {
+        await inlineCompletion.reportInlineEditShown(this._commandService);
     }
 };
 InlineCompletionsModel = ( __decorate([
     ( __param(7, IInstantiationService)),
     ( __param(8, ICommandService)),
     ( __param(9, ILanguageConfigurationService)),
-    ( __param(10, IAccessibilityService))
+    ( __param(10, IAccessibilityService)),
+    ( __param(11, ILanguageFeaturesService))
 ], InlineCompletionsModel));
 var VersionIdChangeReason;
 (function (VersionIdChangeReason) {