@codingame/monaco-vscode-api 19.1.4 → 20.0.0

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

@@ -2,11 +2,11 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { mapFindFirst } from '../../../../../base/common/arraysFind.js';
 import { itemsEquals } from '../../../../../base/common/equals.js';
-import { BugIndicatingError, onUnexpectedExternalError, onUnexpectedError } from '../../../../../base/common/errors.js';
+import { BugIndicatingError, onUnexpectedExternalError } 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';
+import { firstNonWhitespaceIndex } from '../../../../../base/common/strings.js';
 import { isDefined } from '../../../../../base/common/types.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
 import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
@@ -27,7 +27,7 @@ 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 { removeTextReplacementCommonSuffixPrefix, getEndPositionsAfterApplying, subtractPositions, substringPos, addPositions } from '../utils.js';
+import { removeTextReplacementCommonSuffixPrefix, getEndPositionsAfterApplying } from '../utils.js';
 import { AnimatedValue, easeOutCubic, ObservableAnimatedValue } from './animation.js';
 import { computeGhostText } from './computeGhostText.js';
 import { ghostTextsOrReplacementsEqual, GhostText, ghostTextOrReplacementEquals } from './ghostText.js';
@@ -35,9 +35,12 @@ import { InlineCompletionsSource } from './inlineCompletionsSource.js';
 import { InlineEdit } from './inlineEdit.js';
 import { InlineCompletionEditorType } from './provideInlineCompletions.js';
 import { singleTextRemoveCommonPrefix, singleTextEditAugments } from './singleTextEditHelpers.js';
-import { EditReasons } from '../../../../common/textModelEditReason.js';
+import { EditSources } from '../../../../common/textModelEditSource.js';
 import { ICodeEditorService } from '../../../../browser/services/codeEditorService.service.js';
 import { IInlineCompletionsService } from '../../../../browser/services/inlineCompletionsService.service.js';
+import { TypingInterval } from './typingSpeed.js';
+import { StringReplacement } from '../../../../common/core/edits/stringEdit.js';
+import { OffsetRange } from '../../../../common/core/ranges/offsetRange.js';
 import { derived, derivedHandleChanges, derivedOpts } from '../../../../../base/common/observableInternal/observables/derived.js';
 import { transaction, subtransaction } from '../../../../../base/common/observableInternal/transaction.js';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
@@ -49,7 +52,7 @@ import { constObservable } from '../../../../../base/common/observableInternal/o
 
 let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
     get isAcceptingPartially() { return this._isAcceptingPartially; }
-    constructor(textModel, _selectedSuggestItem, _textModelVersionId, _positions, _debounceValue, _enabled, _editor, _instantiationService, _commandService, _languageConfigurationService, _accessibilityService, _languageFeaturesService, _codeEditorService, inlineCompletionsService) {
+    constructor(textModel, _selectedSuggestItem, _textModelVersionId, _positions, _debounceValue, _enabled, _editor, _instantiationService, _commandService, _languageConfigurationService, _accessibilityService, _languageFeaturesService, _codeEditorService, _inlineCompletionsService) {
         super();
         this.textModel = textModel;
         this._selectedSuggestItem = _selectedSuggestItem;
@@ -64,30 +67,35 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         this._accessibilityService = _accessibilityService;
         this._languageFeaturesService = _languageFeaturesService;
         this._codeEditorService = _codeEditorService;
-        this.primaryPosition = derived(this, reader => this._positions.read(reader)[0] ?? ( new Position(1, 1)));
-        this._source = this._register(this._instantiationService.createInstance(InlineCompletionsSource, this.textModel, this._textModelVersionId, this._debounceValue, this.primaryPosition));
+        this._inlineCompletionsService = _inlineCompletionsService;
         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;
+        this._appearedInsideViewport = derived(this, reader => {
+            const state = this.state.read(reader);
+            if (!state || !state.inlineCompletion) {
+                return false;
+            }
+            const targetRange = state.inlineCompletion.targetRange;
+            const visibleRanges = this._editorObs.editor.getVisibleRanges();
+            if (visibleRanges.length < 1) {
+                return false;
+            }
+            const viewportRange = ( new Range(
+                visibleRanges[0].startLineNumber,
+                visibleRanges[0].startColumn,
+                visibleRanges[visibleRanges.length - 1].endLineNumber,
+                visibleRanges[visibleRanges.length - 1].endColumn
+            ));
+            return viewportRange.containsRange(targetRange);
+        });
         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._suppressedInlineCompletionGroupIds = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(v => ( new Set(v.experimental.suppressInlineSuggestions.split(',')))));
-        this._inlineEditsEnabled = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(v => !!v.edits.enabled));
-        this._inlineEditsShowCollapsedEnabled = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.showCollapsed));
-        this._triggerCommandOnProviderChange = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.experimental.triggerCommandOnProviderChange));
-        this._register(inlineCompletionsService.onDidChangeIsSnoozing((isSnoozing) => {
-            if (isSnoozing) {
-                this.stop();
-            }
-        }));
         this._lastShownInlineCompletionInfo = undefined;
         this._lastAcceptedInlineCompletionInfo = undefined;
         this._didUndoInlineEdits = derivedHandleChanges({
@@ -163,7 +171,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             this._forceUpdateExplicitlySignal.read(reader);
             this._fetchSpecificProviderSignal.read(reader);
             const shouldUpdate = ((this._enabled.read(reader) && this._selectedSuggestItem.read(reader)) || this._isActive.read(reader))
-                && (!inlineCompletionsService.isSnoozing() || changeSummary.inlineCompletionTriggerKind === InlineCompletionTriggerKind.Explicit);
+                && (!this._inlineCompletionsService.isSnoozing() || changeSummary.inlineCompletionTriggerKind === InlineCompletionTriggerKind.Explicit);
             if (!shouldUpdate) {
                 this._source.cancelUpdate();
                 return undefined;
@@ -193,17 +201,21 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (changeSummary.changeReason) {
                 reason += reason.length > 0 ? `:${changeSummary.changeReason}` : changeSummary.changeReason;
             }
+            const typingInterval = this._typing.getTypingInterval();
             const requestInfo = {
                 editorType: this.editorType,
                 startTime: Date.now(),
                 languageId: this.textModel.getLanguageId(),
                 reason,
+                typingInterval: typingInterval.averageInterval,
+                typingIntervalCharacterCount: typingInterval.characterCount,
             };
             let context = {
                 triggerKind: changeSummary.inlineCompletionTriggerKind,
                 selectedSuggestionInfo: suggestItem?.toSelectedSuggestionInfo(),
                 includeInlineCompletions: !changeSummary.onlyRequestInlineEdits,
                 includeInlineEdits: this._inlineEditsEnabled.read(reader),
+                requestIssuedDateTime: requestInfo.startTime,
             };
             if (context.triggerKind === InlineCompletionTriggerKind.Automatic && changeSummary.textChange) {
                 if (this.textModel.getAlternativeVersionId() === this._lastShownInlineCompletionInfo?.alternateTextModelVersionId) {
@@ -220,10 +232,12 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             const userJumpedToActiveCompletion = ( this._jumpedToId.map(
                 jumpedTo => !!jumpedTo && jumpedTo === this._inlineCompletionItems.get()?.inlineEdit?.semanticId
             ));
-            const providers = changeSummary.provider ? [changeSummary.provider] : this._languageFeaturesService.inlineCompletionsProvider.all(this.textModel);
+            const providers = changeSummary.provider
+                ? { providers: [changeSummary.provider], label: 'single:' + changeSummary.provider.providerId?.toString() }
+                : { providers: this._languageFeaturesService.inlineCompletionsProvider.all(this.textModel), label: undefined };
             const suppressedProviderGroupIds = this._suppressedInlineCompletionGroupIds.get();
-            const availableProviders = providers.filter(provider => !(provider.groupId && ( suppressedProviderGroupIds.has(provider.groupId))));
-            return this._source.fetch(availableProviders, context, itemToPreserve?.identity, changeSummary.shouldDebounce, userJumpedToActiveCompletion, !!changeSummary.provider, requestInfo);
+            const availableProviders = providers.providers.filter(provider => !(provider.groupId && ( suppressedProviderGroupIds.has(provider.groupId))));
+            return this._source.fetch(availableProviders, providers.label, context, itemToPreserve?.identity, changeSummary.shouldDebounce, userJumpedToActiveCompletion, !!changeSummary.provider, requestInfo);
         });
         this._inlineCompletionItems = derivedOpts({ owner: this }, reader => {
             const c = this._source.inlineCompletions.read(reader);
@@ -272,7 +286,6 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             return filteredCompletions[idx];
         });
         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;
@@ -329,12 +342,14 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 const fullEditPreviewLength = augmentation ? augmentation.edit.text.length - suggestCompletionEdit.text.length : 0;
                 const mode = this._suggestPreviewMode.read(reader);
                 const positions = this._positions.read(reader);
-                const edits = [fullEdit, ...getSecondaryEdits(this.textModel, positions, fullEdit)];
-                const ghostTexts = ( edits
+                const allPotentialEdits = [fullEdit, ...getSecondaryEdits(this.textModel, positions, fullEdit)];
+                const validEditsAndGhostTexts = ( allPotentialEdits
                     .map(
-                    (edit, idx) => computeGhostText(edit, model, mode, positions[idx], fullEditPreviewLength)
+                    (edit, idx) => ({ edit, ghostText: edit ? computeGhostText(edit, model, mode, positions[idx], fullEditPreviewLength) : undefined })
                 ))
-                    .filter(isDefined);
+                    .filter(({ edit, ghostText }) => edit !== undefined && ghostText !== undefined);
+                const edits = ( validEditsAndGhostTexts.map(({ edit }) => edit));
+                const ghostTexts = ( validEditsAndGhostTexts.map(({ ghostText }) => ghostText));
                 const primaryGhostText = ghostTexts[0] ?? ( new GhostText(fullEdit.range.endLineNumber, []));
                 return { kind: 'ghostText', edits, primaryGhostText, ghostTexts, inlineCompletion: augmentation?.completion, suggestItem };
             }
@@ -349,10 +364,14 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 const replacement = inlineCompletion.getSingleTextEdit();
                 const mode = this._inlineSuggestMode.read(reader);
                 const positions = this._positions.read(reader);
-                const edits = [replacement, ...getSecondaryEdits(this.textModel, positions, replacement)];
-                const ghostTexts = ( edits
-                    .map((edit, idx) => computeGhostText(edit, model, mode, positions[idx], 0)))
-                    .filter(isDefined);
+                const allPotentialEdits = [replacement, ...getSecondaryEdits(this.textModel, positions, replacement)];
+                const validEditsAndGhostTexts = ( allPotentialEdits
+                    .map(
+                    (edit, idx) => ({ edit, ghostText: edit ? computeGhostText(edit, model, mode, positions[idx], 0) : undefined })
+                ))
+                    .filter(({ edit, ghostText }) => edit !== undefined && ghostText !== undefined);
+                const edits = ( validEditsAndGhostTexts.map(({ edit }) => edit));
+                const ghostTexts = ( validEditsAndGhostTexts.map(({ ghostText }) => ghostText));
                 if (!ghostTexts[0]) {
                     return undefined;
                 }
@@ -410,27 +429,6 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             }
             return v?.primaryGhostText;
         });
-        this._jumpedToId = observableValue(this, undefined);
-        this._inAcceptFlow = observableValue(this, false);
-        this.inAcceptFlow = this._inAcceptFlow;
-        const appearedInsideViewport = derived(this, reader => {
-            const state = this.state.read(reader);
-            if (!state || !state.inlineCompletion) {
-                return false;
-            }
-            const targetRange = state.inlineCompletion.targetRange;
-            const visibleRanges = this._editorObs.editor.getVisibleRanges();
-            if (visibleRanges.length < 1) {
-                return false;
-            }
-            const viewportRange = ( new Range(
-                visibleRanges[0].startLineNumber,
-                visibleRanges[0].startColumn,
-                visibleRanges[visibleRanges.length - 1].endLineNumber,
-                visibleRanges[visibleRanges.length - 1].endColumn
-            ));
-            return viewportRange.containsRange(targetRange);
-        });
         this.showCollapsed = derived(this, reader => {
             const state = this.state.read(reader);
             if (!state || state.kind !== 'inlineEdit') {
@@ -478,7 +476,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (this.showCollapsed.read(reader)) {
                 return true;
             }
-            if (this._inAcceptFlow.read(reader) && appearedInsideViewport.read(reader)) {
+            if (this._inAcceptFlow.read(reader) && this._appearedInsideViewport.read(reader)) {
                 return false;
             }
             return !s.cursorAtInlineEdit.read(reader);
@@ -491,7 +489,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (this.showCollapsed.read(reader)) {
                 return false;
             }
-            if (this._inAcceptFlow.read(reader) && appearedInsideViewport.read(reader)) {
+            if (this._inAcceptFlow.read(reader) && this._appearedInsideViewport.read(reader)) {
                 return true;
             }
             if (s.inlineCompletion.targetRange.startLineNumber === this._editorObs.cursorLineNumber.read(reader)) {
@@ -505,12 +503,34 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             }
             return s.cursorAtInlineEdit.read(reader);
         });
+        this._jumpedToId = observableValue(this, undefined);
+        this._inAcceptFlow = observableValue(this, false);
+        this.inAcceptFlow = this._inAcceptFlow;
+        this._source = this._register(this._instantiationService.createInstance(InlineCompletionsSource, this.textModel, this._textModelVersionId, this._debounceValue, this.primaryPosition));
+        this.lastTriggerKind = ( this._source.inlineCompletions.map(this, v => v?.request?.context.triggerKind));
+        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._suppressedInlineCompletionGroupIds = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(v => ( new Set(v.experimental.suppressInlineSuggestions.split(',')))));
+        this._inlineEditsEnabled = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(v => !!v.edits.enabled));
+        this._inlineEditsShowCollapsedEnabled = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.edits.showCollapsed));
+        this._triggerCommandOnProviderChange = ( this._editorObs.getOption(EditorOption.inlineSuggest).map(s => s.experimental.triggerCommandOnProviderChange));
+        this._typing = this._register(( new TypingInterval(this.textModel)));
+        this._register(this._inlineCompletionsService.onDidChangeIsSnoozing((isSnoozing) => {
+            if (isSnoozing) {
+                this.stop();
+            }
+        }));
         {
+            const isNotebook = this.textModel.uri.scheme === 'vscode-notebook-cell';
             const [diffEditor] = this._codeEditorService.listDiffEditors()
                 .filter(d => d.getOriginalEditor().getId() === this._editor.getId() ||
                 d.getModifiedEditor().getId() === this._editor.getId());
-            this.editorType = !!diffEditor ? InlineCompletionEditorType.DiffEditor : InlineCompletionEditorType.TextEditor;
-            this.isInDiffEditor = this.editorType === InlineCompletionEditorType.DiffEditor;
+            this.isInDiffEditor = !!diffEditor;
+            this.editorType = isNotebook ? InlineCompletionEditorType.Notebook
+                : this.isInDiffEditor ? InlineCompletionEditorType.DiffEditor
+                    : InlineCompletionEditorType.TextEditor;
         }
         this._register(recomputeInitiallyAndOnChange(this._fetchInlineCompletionsPromise));
         this._register(autorun(reader => {
@@ -668,18 +688,18 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
     async previous() { await this._deltaSelectedInlineCompletionIndex(-1); }
     _getMetadata(completion, type = undefined) {
         if (type) {
-            return EditReasons.inlineCompletionPartialAccept({
+            return EditSources.inlineCompletionPartialAccept({
                 nes: completion.isInlineEdit,
                 requestUuid: completion.requestUuid,
-                extensionId: completion.source.provider.groupId ?? 'unknown',
+                providerId: completion.source.provider.providerId,
                 type,
             });
         }
         else {
-            return EditReasons.inlineCompletionAccept({
+            return EditSources.inlineCompletionAccept({
                 nes: completion.isInlineEdit,
                 requestUuid: completion.requestUuid,
-                extensionId: completion.source.provider.groupId ?? 'unknown',
+                providerId: completion.source.provider.providerId,
             });
         }
     }
@@ -817,7 +837,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 const replaceRange = Range.fromPositions(cursorPosition, ghostTextPos);
                 const newText = editor.getModel().getValueInRange(replaceRange) + partialGhostTextVal;
                 const primaryEdit = ( new TextReplacement(replaceRange, newText));
-                const edits = [primaryEdit, ...getSecondaryEdits(this.textModel, positions, primaryEdit)];
+                const edits = [primaryEdit, ...getSecondaryEdits(this.textModel, positions, primaryEdit)].filter(isDefined);
                 const selections = ( getEndPositionsAfterApplying(edits).map(p => Selection.fromPositions(p)));
                 editor.edit(TextEdit.fromParallelReplacementsUnsorted(edits), this._getMetadata(completion, type));
                 editor.setSelections(selections, 'inlineCompletionPartialAccept');
@@ -898,29 +918,33 @@ var VersionIdChangeReason;
     VersionIdChangeReason[VersionIdChangeReason["AcceptWord"] = 2] = "AcceptWord";
     VersionIdChangeReason[VersionIdChangeReason["Other"] = 3] = "Other";
 })(VersionIdChangeReason || (VersionIdChangeReason = {}));
-function getSecondaryEdits(textModel, positions, primaryEdit) {
+function getSecondaryEdits(textModel, positions, primaryTextRepl) {
     if (positions.length === 1) {
         return [];
     }
-    const primaryPosition = positions[0];
-    const secondaryPositions = positions.slice(1);
-    const primaryEditStartPosition = primaryEdit.range.getStartPosition();
-    const primaryEditEndPosition = primaryEdit.range.getEndPosition();
-    const replacedTextAfterPrimaryCursor = textModel.getValueInRange(Range.fromPositions(primaryPosition, primaryEditEndPosition));
-    const positionWithinTextEdit = subtractPositions(primaryPosition, primaryEditStartPosition);
-    if (positionWithinTextEdit.lineNumber < 1) {
-        onUnexpectedError(( new BugIndicatingError(`positionWithinTextEdit line number should be bigger than 0.
-			Invalid subtraction between ${( primaryPosition.toString())} and ${( primaryEditStartPosition.toString())}`)));
-        return [];
-    }
-    const secondaryEditText = substringPos(primaryEdit.text, positionWithinTextEdit);
-    return ( secondaryPositions.map(pos => {
-        const posEnd = addPositions(subtractPositions(pos, primaryEditStartPosition), primaryEditEndPosition);
-        const textAfterSecondaryCursor = textModel.getValueInRange(Range.fromPositions(pos, posEnd));
-        const l = commonPrefixLength(replacedTextAfterPrimaryCursor, textAfterSecondaryCursor);
-        const range = Range.fromPositions(pos, pos.delta(0, l));
-        return ( new TextReplacement(range, secondaryEditText));
-    }));
+    const text = ( new TextModelText(textModel));
+    const textTransformer = text.getTransformer();
+    const primaryOffset = textTransformer.getOffset(positions[0]);
+    const secondaryOffsets = ( positions.slice(1).map(pos => textTransformer.getOffset(pos)));
+    primaryTextRepl = primaryTextRepl.removeCommonPrefixAndSuffix(text);
+    const primaryStringRepl = textTransformer.getStringReplacement(primaryTextRepl);
+    const deltaFromOffsetToRangeStart = primaryStringRepl.replaceRange.start - primaryOffset;
+    const primaryContextRange = primaryStringRepl.replaceRange.join(OffsetRange.emptyAt(primaryOffset));
+    const primaryContextValue = text.getValueOfOffsetRange(primaryContextRange);
+    const replacements = ( secondaryOffsets.map(secondaryOffset => {
+        const newRangeStart = secondaryOffset + deltaFromOffsetToRangeStart;
+        const newRangeEnd = newRangeStart + primaryStringRepl.replaceRange.length;
+        const range = ( new OffsetRange(newRangeStart, newRangeEnd));
+        const contextRange = range.join(OffsetRange.emptyAt(secondaryOffset));
+        const contextValue = text.getValueOfOffsetRange(contextRange);
+        if (contextValue !== primaryContextValue) {
+            return undefined;
+        }
+        const stringRepl = ( new StringReplacement(range, primaryStringRepl.newText));
+        const repl = textTransformer.getTextReplacement(stringRepl);
+        return repl;
+    })).filter(isDefined);
+    return replacements;
 }
 class FadeoutDecoration extends Disposable {
     constructor(editor, ranges, onDispose) {

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

@@ -33,7 +33,7 @@ export declare class InlineCompletionsSource extends Disposable {
     private _log;
     private readonly _loadingCount;
     readonly loading: IObservable<boolean>;
-    fetch(providers: InlineCompletionsProvider[], context: InlineCompletionContextWithoutUuid, activeInlineCompletion: InlineSuggestionIdentity | undefined, withDebounce: boolean, userJumpedToActiveCompletion: IObservable<boolean>, providerhasChangedCompletion: boolean, requestInfo: InlineSuggestRequestInfo): Promise<boolean>;
+    fetch(providers: InlineCompletionsProvider[], providersLabel: string | undefined, context: InlineCompletionContextWithoutUuid, activeInlineCompletion: InlineSuggestionIdentity | undefined, withDebounce: boolean, userJumpedToActiveCompletion: IObservable<boolean>, providerhasChangedCompletion: boolean, requestInfo: InlineSuggestRequestInfo): Promise<boolean>;
     clear(tx: ITransaction): void;
     seedInlineCompletionsWithSuggestWidget(): void;
     clearSuggestWidgetInlineCompletions(tx: ITransaction): void;

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

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { compareUndefinedSmallest, numberComparator } from '../../../../../base/common/arrays.js';
+import { compareUndefinedSmallest, numberComparator, compareBy, booleanComparator } from '../../../../../base/common/arrays.js';
 import { findLastMax } from '../../../../../base/common/arraysFind.js';
 import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
 import { equalsIfDefined, itemEquals } from '../../../../../base/common/equals.js';
@@ -20,10 +20,10 @@ import { StructuredLogger, formatRecordableLogEntry } from '../structuredLogger.
 import { wait } from '../utils.js';
 import { InlineSuggestionItem } from './inlineSuggestionItem.js';
 import { provideInlineCompletions, runWhenCancelled } from './provideInlineCompletions.js';
+import { recordChangesLazy } from '../../../../../base/common/observableInternal/changeTracker.js';
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
 import { transaction } from '../../../../../base/common/observableInternal/transaction.js';
-import { recordChanges } from '../../../../../base/common/observableInternal/changeTracker.js';
 
 var InlineCompletionsSource_1;
 let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
@@ -40,8 +40,6 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         this._configurationService = _configurationService;
         this._instantiationService = _instantiationService;
         this._updateOperation = this._register(( new MutableDisposable()));
-        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(),
@@ -51,7 +49,7 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
                 values.inlineCompletions.dispose();
                 values.suggestWidgetInlineCompletions.dispose();
             },
-            changeTracker: recordChanges({ versionId: this._versionId }),
+            changeTracker: recordChangesLazy(() => ({ versionId: this._versionId })),
             update: (reader, previousValue, changes) => {
                 const edit = StringEdit.compose(( changes.changes.map(
                     c => c.change ? offsetEditFromContentChanges(c.change.changes) : StringEdit.empty
@@ -80,6 +78,8 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         });
         this._loadingCount = observableValue(this, 0);
         this.loading = ( this._loadingCount.map(this, v => v > 0));
+        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.recomputeInitiallyAndOnChange(this._store);
     }
     _log(entry) {
@@ -88,7 +88,7 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         }
         this._structuredFetchLogger.log(entry);
     }
-    fetch(providers, context, activeInlineCompletion, withDebounce, userJumpedToActiveCompletion, providerhasChangedCompletion, requestInfo) {
+    fetch(providers, providersLabel, context, activeInlineCompletion, withDebounce, userJumpedToActiveCompletion, providerhasChangedCompletion, requestInfo) {
         const position = this._cursorPosition.get();
         const request = ( new UpdateRequest(position, context, this._textModel.getVersionId(), ( new Set(providers))));
         const target = context.selectedSuggestionInfo ? this.suggestWidgetInlineCompletions.get() : this.inlineCompletions.get();
@@ -116,7 +116,16 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
                 }
                 const requestId = InlineCompletionsSource_1._requestId++;
                 if (this._loggingEnabled.get() || this._structuredFetchLogger.isEnabled.get()) {
-                    this._log({ sourceId: 'InlineCompletions.fetch', kind: 'start', requestId, modelUri: this._textModel.uri, modelVersion: this._textModel.getVersionId(), context: { triggerKind: context.triggerKind }, time: Date.now() });
+                    this._log({
+                        sourceId: 'InlineCompletions.fetch',
+                        kind: 'start',
+                        requestId,
+                        modelUri: this._textModel.uri,
+                        modelVersion: this._textModel.getVersionId(),
+                        context: { triggerKind: context.triggerKind, suggestInfo: context.selectedSuggestionInfo ? true : undefined },
+                        time: Date.now(),
+                        provider: providersLabel,
+                    });
                 }
                 const startTime = ( new Date());
                 const providerResult = provideInlineCompletions(providers, this._cursorPosition.get(), this._textModel, context, requestInfo, this._languageConfigurationService);
@@ -323,13 +332,14 @@ class InlineCompletionsState extends Disposable {
         const preferInlineCompletions = itemToPreserve
             ? !itemToPreserve.isInlineEdit
             : ( updatedSuggestions.some(i => !i.isInlineEdit && i.isVisible(textModel, cursorPosition)));
-        const updatedItems = [];
+        let updatedItems = [];
         for (const i of updatedSuggestions) {
             const oldItem = this._findByHash(i.hash);
             let item;
             if (oldItem && oldItem !== i) {
                 item = i.withIdentity(oldItem.identity);
                 oldItem.setEndOfLifeReason({ kind: InlineCompletionEndOfLifeReasonKind.Ignored, userTypingDisagreed: false, supersededBy: i.getSourceCompletion() });
+                i.setIsPreceeded();
             }
             else {
                 item = i;
@@ -338,12 +348,25 @@ class InlineCompletionsState extends Disposable {
                 updatedItems.push(item);
             }
         }
+        updatedItems.sort(compareBy(i => i.showInlineEditMenu, booleanComparator));
+        updatedItems = distinctByKey(updatedItems, i => i.semanticId);
         return ( new InlineCompletionsState(updatedItems, request));
     }
     clone() {
         return ( new InlineCompletionsState(this.inlineCompletions, this.request));
     }
 }
+function distinctByKey(items, key) {
+    const seen = ( new Set());
+    return items.filter(item => {
+        const k = key(item);
+        if (( seen.has(k))) {
+            return false;
+        }
+        seen.add(k);
+        return true;
+    });
+}
 function moveToFront(item, items) {
     const index = items.indexOf(item);
     if (index > -1) {

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

@@ -45,6 +45,7 @@ declare abstract class InlineSuggestionItemBase {
     reportEndOfLife(reason: InlineCompletionEndOfLifeReason): void;
     setEndOfLifeReason(reason: InlineCompletionEndOfLifeReason): void;
     reportInlineEditError(reason: string): void;
+    setIsPreceeded(): void;
     getSourceCompletion(): InlineCompletion;
 }
 export declare class InlineSuggestionIdentity {
@@ -57,15 +58,15 @@ export declare class InlineSuggestionIdentity {
     removeRef(): void;
 }
 declare class InlineSuggestDisplayLocation implements IDisplayLocation {
-    private readonly _offsetRange;
     readonly range: Range;
     readonly label: string;
-    static create(displayLocation: IDisplayLocation, textmodel: ITextModel): InlineSuggestDisplayLocation;
+    static create(displayLocation: IDisplayLocation): InlineSuggestDisplayLocation;
     private constructor();
     withEdit(edit: StringEdit, positionOffsetTransformer: PositionOffsetTransformerBase): InlineSuggestDisplayLocation | undefined;
 }
 export declare class InlineCompletionItem extends InlineSuggestionItemBase {
     private readonly _edit;
+    private readonly _trimmedEdit;
     private readonly _textEdit;
     private readonly _originalRange;
     readonly snippetInfo: SnippetInfo | undefined;
@@ -73,6 +74,7 @@ export declare class InlineCompletionItem extends InlineSuggestionItemBase {
     static create(data: InlineSuggestData, textModel: ITextModel): InlineCompletionItem;
     readonly isInlineEdit = false;
     private constructor();
+    get hash(): string;
     getSingleTextEdit(): TextReplacement;
     withIdentity(identity: InlineSuggestionIdentity): InlineCompletionItem;
     withEdit(textModelEdit: StringEdit, textModel: ITextModel): InlineCompletionItem | undefined;

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

@@ -78,6 +78,9 @@ class InlineSuggestionItemBase {
     reportInlineEditError(reason) {
         this._data.reportInlineEditError(reason);
     }
+    setIsPreceeded() {
+        this._data.setIsPreceeded();
+    }
     getSourceCompletion() {
         return this._sourceInlineCompletion;
     }
@@ -101,25 +104,24 @@ class InlineSuggestionIdentity {
     }
 }
 class InlineSuggestDisplayLocation {
-    static create(displayLocation, textmodel) {
-        const offsetRange = ( new OffsetRange(
-            textmodel.getOffsetAt(displayLocation.range.getStartPosition()),
-            textmodel.getOffsetAt(displayLocation.range.getEndPosition())
-        ));
-        return ( new InlineSuggestDisplayLocation(offsetRange, displayLocation.range, displayLocation.label));
+    static create(displayLocation) {
+        return ( new InlineSuggestDisplayLocation(displayLocation.range, displayLocation.label));
     }
-    constructor(_offsetRange, range, label) {
-        this._offsetRange = _offsetRange;
+    constructor(range, label) {
         this.range = range;
         this.label = label;
     }
     withEdit(edit, positionOffsetTransformer) {
-        const newOffsetRange = applyEditsToRanges([this._offsetRange], edit)[0];
-        if (!newOffsetRange || newOffsetRange.length !== this._offsetRange.length) {
+        const offsetRange = ( new OffsetRange(
+            positionOffsetTransformer.getOffset(this.range.getStartPosition()),
+            positionOffsetTransformer.getOffset(this.range.getEndPosition())
+        ));
+        const newOffsetRange = applyEditsToRanges([offsetRange], edit)[0];
+        if (!newOffsetRange) {
             return undefined;
         }
         const newRange = positionOffsetTransformer.getRange(newOffsetRange);
-        return ( new InlineSuggestDisplayLocation(newOffsetRange, newRange, this.label));
+        return ( new InlineSuggestDisplayLocation(newRange, this.label));
     }
 }
 class InlineCompletionItem extends InlineSuggestionItemBase {
@@ -128,10 +130,12 @@ class InlineCompletionItem extends InlineSuggestionItemBase {
         const transformer = getPositionOffsetTransformerFromTextModel(textModel);
         const insertText = data.insertText.replace(/\r\n|\r|\n/g, textModel.getEOL());
         const edit = reshapeInlineCompletion(( new StringReplacement(transformer.getOffsetRange(data.range), insertText)), textModel);
-        const textEdit = transformer.getSingleTextEdit(edit);
-        const displayLocation = data.displayLocation ? InlineSuggestDisplayLocation.create(data.displayLocation, textModel) : undefined;
+        const trimmedEdit = edit.removeCommonSuffixAndPrefix(textModel.getValue());
+        const textEdit = transformer.getTextReplacement(edit);
+        const displayLocation = data.displayLocation ? InlineSuggestDisplayLocation.create(data.displayLocation) : undefined;
         return ( new InlineCompletionItem(
             edit,
+            trimmedEdit,
             textEdit,
             textEdit.range,
             data.snippetInfo,
@@ -141,19 +145,24 @@ class InlineCompletionItem extends InlineSuggestionItemBase {
             displayLocation
         ));
     }
-    constructor(_edit, _textEdit, _originalRange, snippetInfo, additionalTextEdits, data, identity, displayLocation) {
+    constructor(_edit, _trimmedEdit, _textEdit, _originalRange, snippetInfo, additionalTextEdits, data, identity, displayLocation) {
         super(data, identity, displayLocation);
         this._edit = _edit;
+        this._trimmedEdit = _trimmedEdit;
         this._textEdit = _textEdit;
         this._originalRange = _originalRange;
         this.snippetInfo = snippetInfo;
         this.additionalTextEdits = additionalTextEdits;
         this.isInlineEdit = false;
     }
+    get hash() {
+        return JSON.stringify(this._trimmedEdit.toJson());
+    }
     getSingleTextEdit() { return this._textEdit; }
     withIdentity(identity) {
         return ( new InlineCompletionItem(
             this._edit,
+            this._trimmedEdit,
             this._textEdit,
             this._originalRange,
             this.snippetInfo,
@@ -170,7 +179,7 @@ class InlineCompletionItem extends InlineSuggestionItemBase {
         }
         const newEdit = ( new StringReplacement(newEditRange[0], this._textEdit.text));
         const positionOffsetTransformer = getPositionOffsetTransformerFromTextModel(textModel);
-        const newTextEdit = positionOffsetTransformer.getSingleTextEdit(newEdit);
+        const newTextEdit = positionOffsetTransformer.getTextReplacement(newEdit);
         let newDisplayLocation = this.displayLocation;
         if (newDisplayLocation) {
             newDisplayLocation = newDisplayLocation.withEdit(textModelEdit, positionOffsetTransformer);
@@ -178,8 +187,10 @@ class InlineCompletionItem extends InlineSuggestionItemBase {
                 return undefined;
             }
         }
+        const trimmedEdit = newEdit.removeCommonSuffixAndPrefix(textModel.getValue());
         return ( new InlineCompletionItem(
             newEdit,
+            trimmedEdit,
             newTextEdit,
             this._originalRange,
             this.snippetInfo,
@@ -245,7 +256,7 @@ class InlineEditItem extends InlineSuggestionItemBase {
             const replacedText = textModel.getValueInRange(replacedRange);
             return SingleUpdatedNextEdit.create(edit, replacedText);
         }));
-        const displayLocation = data.displayLocation ? InlineSuggestDisplayLocation.create(data.displayLocation, textModel) : undefined;
+        const displayLocation = data.displayLocation ? InlineSuggestDisplayLocation.create(data.displayLocation) : undefined;
         return ( new InlineEditItem(
             offsetEdit,
             singleTextEdit,