monaco-editor-core 0.56.0-dev-20251124 → 0.56.0-dev-20251217

package/esm/vs/editor/contrib/inlineCompletions/browser/model/inlineSuggestionItem.js

@@ -3,7 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import { BugIndicatingError } from '../../../../../base/common/errors.js';
-import { matchesSubString } from '../../../../../base/common/filters.js';
 import { observableSignal, observableValue } from '../../../../../base/common/observable.js';
 import { commonPrefixLength, commonSuffixLength, splitLines } from '../../../../../base/common/strings.js';
 import { applyEditsToRanges, StringEdit, StringReplacement } from '../../../../common/core/edits/stringEdit.js';
@@ -16,19 +15,25 @@ import { TextLength } from '../../../../common/core/text/textLength.js';
 import { linesDiffComputers } from '../../../../common/diff/linesDiffComputers.js';
 import { InlineCompletionTriggerKind } from '../../../../common/languages.js';
 import { TextModelText } from '../../../../common/model/textModelText.js';
-import { singleTextRemoveCommonPrefix } from './singleTextEditHelpers.js';
+import { computeEditKind } from './editKind.js';
+import { inlineCompletionIsVisible } from './inlineCompletionIsVisible.js';
+import { InlineSuggestAlternativeAction } from './InlineSuggestAlternativeAction.js';
 export var InlineSuggestionItem;
 (function (InlineSuggestionItem) {
-    function create(data, textModel) {
-        if (!data.isInlineEdit && !data.uri) {
-            return InlineCompletionItem.create(data, textModel);
+    function create(data, textModel, shouldDiffEdit = true) {
+        if (!data.isInlineEdit && !data.action?.uri && data.action?.kind === 'edit') {
+            return InlineCompletionItem.create(data, textModel, data.action);
         }
         else {
-            return InlineEditItem.create(data, textModel);
+            return InlineEditItem.create(data, textModel, shouldDiffEdit);
         }
     }
     InlineSuggestionItem.create = create;
 })(InlineSuggestionItem || (InlineSuggestionItem = {}));
+function hashInlineSuggestionAction(action) {
+    const obj = action?.kind === 'edit' ? { ...action, alternativeAction: InlineSuggestAlternativeAction.toString(action.alternativeAction) } : action;
+    return JSON.stringify(obj);
+}
 class InlineSuggestionItemBase {
     constructor(_data, identity, hint) {
         this._data = _data;
@@ -42,19 +47,26 @@ class InlineSuggestionItemBase {
     get source() { return this._data.source; }
     get isFromExplicitRequest() { return this._data.context.triggerKind === InlineCompletionTriggerKind.Explicit; }
     get forwardStable() { return this.source.inlineSuggestions.enableForwardStability ?? false; }
-    get editRange() { return this.getSingleTextEdit().range; }
-    get targetRange() { return this.hint?.range ?? this.editRange; }
-    get insertText() { return this.getSingleTextEdit().text; }
+    get targetRange() {
+        if (this.hint) {
+            return this.hint.range;
+        }
+        if (this.action?.kind === 'edit') {
+            return this.action.textReplacement.range;
+        }
+        else if (this.action?.kind === 'jumpTo') {
+            return Range.fromPositions(this.action.position);
+        }
+        throw new BugIndicatingError('InlineSuggestionItem: Either hint or action must be set');
+    }
     get semanticId() { return this.hash; }
-    get action() { return this._sourceInlineCompletion.gutterMenuLinkAction; }
+    get gutterMenuLinkAction() { return this._sourceInlineCompletion.gutterMenuLinkAction; }
     get command() { return this._sourceInlineCompletion.command; }
+    get supportsRename() { return this._data.supportsRename; }
     get warning() { return this._sourceInlineCompletion.warning; }
     get showInlineEditMenu() { return !!this._sourceInlineCompletion.showInlineEditMenu; }
     get hash() {
-        return JSON.stringify([
-            this.getSingleTextEdit().text,
-            this.getSingleTextEdit().range.getStartPosition().toString()
-        ]);
+        return hashInlineSuggestionAction(this.action);
     }
     get requestUuid() { return this._data.context.requestUuid; }
     get partialAccepts() { return this._data.partialAccepts; }
@@ -71,8 +83,9 @@ class InlineSuggestionItemBase {
         this.identity.removeRef();
         this.source.removeRef();
     }
-    reportInlineEditShown(commandService, viewKind, viewData) {
-        this._data.reportInlineEditShown(commandService, this.insertText, viewKind, viewData);
+    reportInlineEditShown(commandService, viewKind, viewData, model, timeWhenShown) {
+        const insertText = this.action?.kind === 'edit' ? this.action.textReplacement.text : ''; // TODO@hediet support insertText === undefined
+        this._data.reportInlineEditShown(commandService, insertText, viewKind, viewData, this.computeEditKind(model), timeWhenShown);
     }
     reportPartialAccept(acceptedCharacters, info, partialAcceptance) {
         this._data.reportPartialAccept(acceptedCharacters, info, partialAcceptance);
@@ -95,6 +108,15 @@ class InlineSuggestionItemBase {
     getSourceCompletion() {
         return this._sourceInlineCompletion;
     }
+    setRenameProcessingInfo(info) {
+        this._data.setRenameProcessingInfo(info);
+    }
+    withAction(action) {
+        return this._data.withAction(action);
+    }
+    addPerformanceMarker(marker) {
+        this._data.addPerformanceMarker(marker);
+    }
 }
 export class InlineSuggestionIdentity {
     constructor() {
@@ -121,8 +143,8 @@ export class InlineSuggestionIdentity {
     }
 }
 export class InlineSuggestHint {
-    static create(displayLocation) {
-        return new InlineSuggestHint(Range.lift(displayLocation.range), displayLocation.content, displayLocation.style);
+    static create(hint) {
+        return new InlineSuggestHint(Range.lift(hint.range), hint.content, hint.style);
     }
     constructor(range, content, style) {
         this.range = range;
@@ -140,15 +162,15 @@ export class InlineSuggestHint {
     }
 }
 export class InlineCompletionItem extends InlineSuggestionItemBase {
-    static create(data, textModel) {
+    static create(data, textModel, action) {
         const identity = new InlineSuggestionIdentity();
         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 insertText = action.insertText.replace(/\r\n|\r|\n/g, textModel.getEOL());
+        const edit = reshapeInlineCompletion(new StringReplacement(transformer.getOffsetRange(action.range), insertText), textModel);
         const trimmedEdit = edit.removeCommonSuffixAndPrefix(textModel.getValue());
         const textEdit = transformer.getTextReplacement(edit);
         const displayLocation = data.hint ? InlineSuggestHint.create(data.hint) : undefined;
-        return new InlineCompletionItem(edit, trimmedEdit, textEdit, textEdit.range, data.snippetInfo, data.additionalTextEdits, data, identity, displayLocation);
+        return new InlineCompletionItem(edit, trimmedEdit, textEdit, textEdit.range, action.snippetInfo, data.additionalTextEdits, data, identity, displayLocation);
     }
     constructor(_edit, _trimmedEdit, _textEdit, _originalRange, snippetInfo, additionalTextEdits, data, identity, displayLocation) {
         super(data, identity, displayLocation);
@@ -160,6 +182,16 @@ export class InlineCompletionItem extends InlineSuggestionItemBase {
         this.additionalTextEdits = additionalTextEdits;
         this.isInlineEdit = false;
     }
+    get action() {
+        return {
+            kind: 'edit',
+            textReplacement: this.getSingleTextEdit(),
+            snippetInfo: this.snippetInfo,
+            stringEdit: new StringEdit([this._trimmedEdit]),
+            uri: undefined,
+            alternativeAction: undefined,
+        };
+    }
     get hash() {
         return JSON.stringify(this._trimmedEdit.toJson());
     }
@@ -198,61 +230,55 @@ export class InlineCompletionItem extends InlineSuggestionItemBase {
         const singleTextEdit = this.getSingleTextEdit();
         return inlineCompletionIsVisible(singleTextEdit, this._originalRange, model, cursorPosition);
     }
-}
-export function inlineCompletionIsVisible(singleTextEdit, originalRange, model, cursorPosition) {
-    const minimizedReplacement = singleTextRemoveCommonPrefix(singleTextEdit, model);
-    const editRange = singleTextEdit.range;
-    if (!editRange
-        || (originalRange && !originalRange.getStartPosition().equals(editRange.getStartPosition()))
-        || cursorPosition.lineNumber !== minimizedReplacement.range.startLineNumber
-        || minimizedReplacement.isEmpty // if the completion is empty after removing the common prefix of the completion and the model, the completion item would not be visible
-    ) {
-        return false;
-    }
-    // We might consider comparing by .toLowerText, but this requires GhostTextReplacement
-    const originalValue = model.getValueInRange(minimizedReplacement.range, 1 /* 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) {
-        // Remove indentation
-        originalValueBefore = originalValueBefore.trimStart();
-        if (originalValueBefore.length === 0) {
-            originalValueAfter = originalValueAfter.trimStart();
-        }
-        filterTextBefore = filterTextBefore.trimStart();
-        if (filterTextBefore.length === 0) {
-            filterTextAfter = filterTextAfter.trimStart();
-        }
+    computeEditKind(model) {
+        return computeEditKind(new StringEdit([this._edit]), model);
     }
-    return filterTextBefore.startsWith(originalValueBefore)
-        && !!matchesSubString(originalValueAfter, filterTextAfter);
+    get editRange() { return this.getSingleTextEdit().range; }
 }
 export class InlineEditItem extends InlineSuggestionItemBase {
-    static create(data, textModel) {
-        const offsetEdit = getStringEdit(textModel, data.range, data.insertText); // TODO compute async
-        const text = new TextModelText(textModel);
-        const textEdit = TextEdit.fromStringEdit(offsetEdit, text);
-        const singleTextEdit = offsetEdit.isEmpty() ? new TextReplacement(new Range(1, 1, 1, 1), '') : textEdit.toReplacement(text); // FIXME: .toReplacement() can throw because offsetEdit is empty because we get an empty diff in getStringEdit after diffing
+    static create(data, textModel, shouldDiffEdit = true) {
+        let action;
+        let edits = [];
+        if (data.action?.kind === 'edit') {
+            const offsetEdit = shouldDiffEdit ? getDiffedStringEdit(textModel, data.action.range, data.action.insertText) : getStringEdit(textModel, data.action.range, data.action.insertText); // TODO compute async
+            const text = new TextModelText(textModel);
+            const textEdit = TextEdit.fromStringEdit(offsetEdit, text);
+            const singleTextEdit = offsetEdit.isEmpty() ? new TextReplacement(new Range(1, 1, 1, 1), '') : textEdit.toReplacement(text); // FIXME: .toReplacement() can throw because offsetEdit is empty because we get an empty diff in getStringEdit after diffing
+            edits = offsetEdit.replacements.map(edit => {
+                const replacedRange = Range.fromPositions(textModel.getPositionAt(edit.replaceRange.start), textModel.getPositionAt(edit.replaceRange.endExclusive));
+                const replacedText = textModel.getValueInRange(replacedRange);
+                return SingleUpdatedNextEdit.create(edit, replacedText);
+            });
+            action = {
+                kind: 'edit',
+                snippetInfo: data.action.snippetInfo,
+                stringEdit: offsetEdit,
+                textReplacement: singleTextEdit,
+                uri: data.action.uri,
+                alternativeAction: data.action.alternativeAction,
+            };
+        }
+        else if (data.action?.kind === 'jumpTo') {
+            action = {
+                kind: 'jumpTo',
+                position: data.action.position,
+                offset: textModel.getOffsetAt(data.action.position),
+                uri: data.action.uri,
+            };
+        }
+        else {
+            action = undefined;
+            if (!data.hint) {
+                throw new BugIndicatingError('InlineEditItem: action is undefined and no hint is provided');
+            }
+        }
         const identity = new InlineSuggestionIdentity();
-        const edits = offsetEdit.replacements.map(edit => {
-            const replacedRange = Range.fromPositions(textModel.getPositionAt(edit.replaceRange.start), textModel.getPositionAt(edit.replaceRange.endExclusive));
-            const replacedText = textModel.getValueInRange(replacedRange);
-            return SingleUpdatedNextEdit.create(edit, replacedText);
-        });
         const hint = data.hint ? InlineSuggestHint.create(data.hint) : undefined;
-        return new InlineEditItem(offsetEdit, singleTextEdit, data.uri, data, identity, edits, hint, false, textModel.getVersionId());
+        return new InlineEditItem(action, data, identity, edits, hint, false, textModel.getVersionId());
     }
-    constructor(_edit, // TODO@hediet remove, compute & cache from _edits
-    _textEdit, uri, data, identity, _edits, hint, _lastChangePartOfInlineEdit = false, _inlineEditModelVersion) {
+    constructor(_action, data, identity, _edits, hint, _lastChangePartOfInlineEdit = false, _inlineEditModelVersion) {
         super(data, identity, hint);
-        this._edit = _edit;
-        this._textEdit = _textEdit;
-        this.uri = uri;
+        this._action = _action;
         this._edits = _edits;
         this._lastChangePartOfInlineEdit = _lastChangePartOfInlineEdit;
         this._inlineEditModelVersion = _inlineEditModelVersion;
@@ -261,12 +287,12 @@ export class InlineEditItem extends InlineSuggestionItemBase {
         this.isInlineEdit = true;
     }
     get updatedEditModelVersion() { return this._inlineEditModelVersion; }
-    get updatedEdit() { return this._edit; }
-    getSingleTextEdit() {
-        return this._textEdit;
+    // public get updatedEdit(): StringEdit { return this._edit; }
+    get action() {
+        return this._action;
     }
     withIdentity(identity) {
-        return new InlineEditItem(this._edit, this._textEdit, this.uri, this._data, identity, this._edits, this.hint, this._lastChangePartOfInlineEdit, this._inlineEditModelVersion);
+        return new InlineEditItem(this._action, this._data, identity, this._edits, this.hint, this._lastChangePartOfInlineEdit, this._inlineEditModelVersion);
     }
     canBeReused(model, position) {
         // TODO@hediet I believe this can be simplified to `return true;`, as applying an edit should kick out this suggestion.
@@ -277,26 +303,55 @@ export class InlineEditItem extends InlineSuggestionItemBase {
         return edit;
     }
     _applyTextModelChanges(textModelChanges, edits, textModel) {
-        edits = edits.map(innerEdit => innerEdit.applyTextModelChanges(textModelChanges));
-        if (edits.some(edit => edit.edit === undefined)) {
-            return undefined; // change is invalid, so we will have to drop the completion
-        }
-        const newTextModelVersion = textModel.getVersionId();
+        const positionOffsetTransformer = getPositionOffsetTransformerFromTextModel(textModel);
+        let lastChangePartOfInlineEdit = false;
         let inlineEditModelVersion = this._inlineEditModelVersion;
-        const lastChangePartOfInlineEdit = edits.some(edit => edit.lastChangeUpdatedEdit);
-        if (lastChangePartOfInlineEdit) {
-            inlineEditModelVersion = newTextModelVersion ?? -1;
+        let newAction;
+        if (this.action?.kind === 'edit') { // TODO What about rename?
+            edits = edits.map(innerEdit => innerEdit.applyTextModelChanges(textModelChanges));
+            if (edits.some(edit => edit.edit === undefined)) {
+                return undefined; // change is invalid, so we will have to drop the completion
+            }
+            const newTextModelVersion = textModel.getVersionId();
+            lastChangePartOfInlineEdit = edits.some(edit => edit.lastChangeUpdatedEdit);
+            if (lastChangePartOfInlineEdit) {
+                inlineEditModelVersion = newTextModelVersion ?? -1;
+            }
+            if (newTextModelVersion === null || inlineEditModelVersion + 20 < newTextModelVersion) {
+                return undefined; // the completion has been ignored for a while, remove it
+            }
+            edits = edits.filter(innerEdit => !innerEdit.edit.isEmpty);
+            if (edits.length === 0) {
+                return undefined; // the completion has been typed by the user
+            }
+            const newEdit = new StringEdit(edits.map(edit => edit.edit));
+            const newTextEdit = positionOffsetTransformer.getTextEdit(newEdit).toReplacement(new TextModelText(textModel));
+            newAction = {
+                kind: 'edit',
+                textReplacement: newTextEdit,
+                snippetInfo: this.snippetInfo,
+                stringEdit: newEdit,
+                uri: this.action.uri,
+                alternativeAction: this.action.alternativeAction,
+            };
         }
-        if (newTextModelVersion === null || inlineEditModelVersion + 20 < newTextModelVersion) {
-            return undefined; // the completion has been ignored for a while, remove it
+        else if (this.action?.kind === 'jumpTo') {
+            const jumpToOffset = this.action.offset;
+            const newJumpToOffset = textModelChanges.applyToOffsetOrUndefined(jumpToOffset);
+            if (newJumpToOffset === undefined) {
+                return undefined;
+            }
+            const newJumpToPosition = positionOffsetTransformer.getPosition(newJumpToOffset);
+            newAction = {
+                kind: 'jumpTo',
+                position: newJumpToPosition,
+                offset: newJumpToOffset,
+                uri: this.action.uri,
+            };
         }
-        edits = edits.filter(innerEdit => !innerEdit.edit.isEmpty);
-        if (edits.length === 0) {
-            return undefined; // the completion has been typed by the user
+        else {
+            newAction = undefined;
         }
-        const newEdit = new StringEdit(edits.map(edit => edit.edit));
-        const positionOffsetTransformer = getPositionOffsetTransformerFromTextModel(textModel);
-        const newTextEdit = positionOffsetTransformer.getTextEdit(newEdit).toReplacement(new TextModelText(textModel));
         let newDisplayLocation = this.hint;
         if (newDisplayLocation) {
             newDisplayLocation = newDisplayLocation.withEdit(textModelChanges, positionOffsetTransformer);
@@ -304,10 +359,17 @@ export class InlineEditItem extends InlineSuggestionItemBase {
                 return undefined;
             }
         }
-        return new InlineEditItem(newEdit, newTextEdit, this.uri, this._data, this.identity, edits, newDisplayLocation, lastChangePartOfInlineEdit, inlineEditModelVersion);
+        return new InlineEditItem(newAction, this._data, this.identity, edits, newDisplayLocation, lastChangePartOfInlineEdit, inlineEditModelVersion);
+    }
+    computeEditKind(model) {
+        const edit = this.action?.kind === 'edit' ? this.action.stringEdit : undefined;
+        if (!edit) {
+            return undefined;
+        }
+        return computeEditKind(edit, model);
     }
 }
-function getStringEdit(textModel, editRange, replaceText) {
+function getDiffedStringEdit(textModel, editRange, replaceText) {
     const eol = textModel.getEOL();
     const editOriginalText = textModel.getValueInRange(editRange);
     const editReplaceText = replaceText.replace(/\r\n|\r|\n/g, eol);
@@ -316,7 +378,7 @@ function getStringEdit(textModel, editRange, replaceText) {
         ignoreTrimWhitespace: false,
         computeMoves: false,
         extendToSubwords: true,
-        maxComputationTimeMs: 500,
+        maxComputationTimeMs: 50,
     });
     const innerChanges = lineDiffs.changes.flatMap(c => c.innerChanges ?? []);
     function addRangeToPos(pos, range) {
@@ -334,6 +396,9 @@ function getStringEdit(textModel, editRange, replaceText) {
     }));
     return offsetEdit;
 }
+function getStringEdit(textModel, editRange, replaceText) {
+    return new StringEdit([new StringReplacement(getPositionOffsetTransformerFromTextModel(textModel).getOffsetRange(editRange), replaceText)]);
+}
 class SingleUpdatedNextEdit {
     static create(edit, replacedText) {
         const prefixLength = commonPrefixLength(edit.newText, replacedText);
@@ -384,7 +449,7 @@ class SingleUpdatedNextEdit {
             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);
+                editEnd += change.newText.length;
                 editHasChanged = true;
                 continue;
             }