@codingame/monaco-vscode-api 2.2.2 → 3.0.0

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys.js

@@ -36,9 +36,9 @@ class InlineCompletionContextKeys extends Disposable {
         this._register(autorun(reader => {
             const model = this.model.read(reader);
             const state = model?.state.read(reader);
-            const isInlineCompletionVisible = !!state?.inlineCompletion && state?.ghostText !== undefined && !state?.ghostText.isEmpty();
+            const isInlineCompletionVisible = !!state?.inlineCompletion && state?.primaryGhostText !== undefined && !state?.primaryGhostText.isEmpty();
             this.inlineCompletionVisible.set(isInlineCompletionVisible);
-            if (state?.ghostText && state?.inlineCompletion) {
+            if (state?.primaryGhostText && state?.inlineCompletion) {
                 this.suppressSuggestions.set(state.inlineCompletion.inlineCompletion.source.inlineCompletions.suppressSuggestions);
             }
         }));
@@ -46,7 +46,7 @@ class InlineCompletionContextKeys extends Disposable {
             const model = this.model.read(reader);
             let startsWithIndentation = false;
             let startsWithIndentationLessThanTabSize = true;
-            const ghostText = model?.ghostText.read(reader);
+            const ghostText = model?.primaryGhostText.read(reader);
             if (!!model?.selectedSuggestItem && ghostText && ghostText.parts.length > 0) {
                 const { column, lines } = ghostText.parts[0];
                 const firstLine = lines[0];

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsController.js

@@ -13,14 +13,14 @@ import { InlineSuggestionHintsContentWidget, InlineCompletionsHintsWidget } from
 import { VersionIdChangeReason, InlineCompletionsModel } from './inlineCompletionsModel.js';
 import { SuggestWidgetAdaptor } from './suggestWidgetInlineCompletionProvider.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { AudioCue, IAudioCueService } from '../../../../platform/audioCues/browser/audioCueService.js';
+import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { observableFromEvent, mapObservableArrayCached, observableSignal, constObservable } from '../../../../base/common/observableInternal/utils.js';
 import { disposableObservableValue, observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
-import { observableFromEvent, constObservable, observableSignal } from '../../../../base/common/observableInternal/utils.js';
 import { derived } from '../../../../base/common/observableInternal/derived.js';
 import { autorun, autorunHandleChanges } from '../../../../base/common/observableInternal/autorun.js';
 var InlineCompletionsController_1;
@@ -30,7 +30,7 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
     static get(editor) {
         return editor.getContribution(InlineCompletionsController_1.ID);
     }
-    constructor(editor, _instantiationService, _contextKeyService, _configurationService, _commandService, _debounceService, _languageFeaturesService, _audioCueService, _keybindingService) {
+    constructor(editor, _instantiationService, _contextKeyService, _configurationService, _commandService, _debounceService, _languageFeaturesService, _accessibilitySignalService, _keybindingService) {
         super();
         this.editor = editor;
         this._instantiationService = _instantiationService;
@@ -39,11 +39,11 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
         this._commandService = _commandService;
         this._debounceService = _debounceService;
         this._languageFeaturesService = _languageFeaturesService;
-        this._audioCueService = _audioCueService;
+        this._accessibilitySignalService = _accessibilitySignalService;
         this._keybindingService = _keybindingService;
-        this.model = disposableObservableValue('inlineCompletionModel', undefined);
+        this.model = this._register(disposableObservableValue('inlineCompletionModel', undefined));
         this._textModelVersionId = observableValue(this, -1);
-        this._cursorPosition = observableValue(this, ( new Position(1, 1)));
+        this._positions = observableValue(this, [( new Position(1, 1))]);
         this._suggestWidgetAdaptor = this._register(( new SuggestWidgetAdaptor(
             this.editor,
             () => this.model.get()?.selectedInlineCompletion.get()?.toSingleTextEdit(undefined),
@@ -57,14 +57,21 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
         )));
         this._enabled = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(62 ).enabled);
         this._fontFamily = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(62 ).fontFamily);
-        this._ghostTextWidget = this._register(this._instantiationService.createInstance(GhostTextWidget, this.editor, {
-            ghostText: ( this.model.map((v, reader) =>  v?.ghostText.read(reader))),
-            minReservedLineCount: constObservable(0),
-            targetTextModel: ( this.model.map(v => v?.textModel)),
-        }));
+        this._ghostTexts = derived(this, (reader) => {
+            const model = this.model.read(reader);
+            return model?.ghostTexts.read(reader) ?? [];
+        });
+        this._stablizedGhostTexts = convertItemsToStableObservables(this._ghostTexts, this._store);
+        this._ghostTextWidgets = mapObservableArrayCached(this, this._stablizedGhostTexts, (ghostText, store) => {
+            return store.add(this._instantiationService.createInstance(GhostTextWidget, this.editor, {
+                ghostText: ghostText,
+                minReservedLineCount: constObservable(0),
+                targetTextModel: ( this.model.map(v => v?.textModel)),
+            }));
+        }).recomputeInitiallyAndOnChange(this._store);
         this._debounceValue = this._debounceService.for(this._languageFeaturesService.inlineCompletionsProvider, 'InlineCompletionsDebounce', { min: 50, max: 50 });
-        this._playAudioCueSignal = observableSignal(this);
-        this._isReadonly = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(90 ));
+        this._playAccessibilitySignal = observableSignal(this);
+        this._isReadonly = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(91 ));
         this._textModel = observableFromEvent(this.editor.onDidChangeModel, () => this.editor.getModel());
         this._textModelIfWritable = derived(reader => this._isReadonly.read(reader) ? undefined : this._textModel.read(reader));
         this._register(( new InlineCompletionContextKeys(this._contextKeyService, this.model)));
@@ -74,7 +81,7 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
                 this.model.set(undefined, tx);
                 this.updateObservables(tx, VersionIdChangeReason.Other);
                 if (textModel) {
-                    const model = _instantiationService.createInstance(InlineCompletionsModel, textModel, this._suggestWidgetAdaptor.selectedItem, this._cursorPosition, this._textModelVersionId, this._debounceValue, observableFromEvent(editor.onDidChangeConfiguration, () => editor.getOption(117 ).preview), observableFromEvent(editor.onDidChangeConfiguration, () => editor.getOption(117 ).previewMode), observableFromEvent(editor.onDidChangeConfiguration, () => editor.getOption(62 ).mode), this._enabled);
+                    const model = _instantiationService.createInstance(InlineCompletionsModel, textModel, this._suggestWidgetAdaptor.selectedItem, this._textModelVersionId, this._positions, this._debounceValue, observableFromEvent(editor.onDidChangeConfiguration, () => editor.getOption(118 ).preview), observableFromEvent(editor.onDidChangeConfiguration, () => editor.getOption(118 ).previewMode), observableFromEvent(editor.onDidChangeConfiguration, () => editor.getOption(62 ).mode), this._enabled);
                     this.model.set(model, tx);
                 }
             });
@@ -144,7 +151,7 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
         this._register(autorun(reader => {
             const state = this.model.read(reader)?.state.read(reader);
             if (state?.suggestItem) {
-                if (state.ghostText.lineCount >= 2) {
+                if (state.primaryGhostText.lineCount >= 2) {
                     this._suggestWidgetAdaptor.forceRenderingAbove();
                 }
             }
@@ -158,13 +165,13 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
         let lastInlineCompletionId = undefined;
         this._register(autorunHandleChanges({
             handleChange: (context, changeSummary) => {
-                if (context.didChange(this._playAudioCueSignal)) {
+                if (context.didChange(this._playAccessibilitySignal)) {
                     lastInlineCompletionId = undefined;
                 }
                 return true;
             },
         }, async (reader) => {
-            this._playAudioCueSignal.read(reader);
+            this._playAccessibilitySignal.read(reader);
             const model = this.model.read(reader);
             const state = model?.state.read(reader);
             if (!model || !state || !state.inlineCompletion) {
@@ -173,10 +180,10 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
             }
             if (state.inlineCompletion.semanticId !== lastInlineCompletionId) {
                 lastInlineCompletionId = state.inlineCompletion.semanticId;
-                const lineText = model.textModel.getLineContent(state.ghostText.lineNumber);
-                this._audioCueService.playAudioCue(AudioCue.inlineSuggestion).then(() => {
+                const lineText = model.textModel.getLineContent(state.primaryGhostText.lineNumber);
+                this._accessibilitySignalService.playSignal(AccessibilitySignal.inlineSuggestion).then(() => {
                     if (this.editor.getOption(8 )) {
-                        this.provideScreenReaderUpdate(state.ghostText.renderForScreenReader(lineText));
+                        this.provideScreenReaderUpdate(state.primaryGhostText.renderForScreenReader(lineText));
                     }
                 });
             }
@@ -189,14 +196,14 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
         }));
         this.editor.updateOptions({ inlineCompletionsAccessibilityVerbose: this._configurationService.getValue('accessibility.verbosity.inlineCompletions') });
     }
-    playAudioCue(tx) {
-        this._playAudioCueSignal.trigger(tx);
+    playAccessibilitySignal(tx) {
+        this._playAccessibilitySignal.trigger(tx);
     }
     provideScreenReaderUpdate(content) {
         const accessibleViewShowing = this._contextKeyService.getContextKeyValue('accessibleViewIsShown');
         const accessibleViewKeybinding = this._keybindingService.lookupKeybinding('editor.action.accessibleView');
         let hint;
-        if (!accessibleViewShowing && accessibleViewKeybinding && this.editor.getOption(147 )) {
+        if (!accessibleViewShowing && accessibleViewKeybinding && this.editor.getOption(148 )) {
             hint = ( localizeWithPath(
                 'vs/editor/contrib/inlineCompletions/browser/inlineCompletionsController',
                 'showAccessibleViewHint',
@@ -209,17 +216,17 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
     updateObservables(tx, changeReason) {
         const newModel = this.editor.getModel();
         this._textModelVersionId.set(newModel?.getVersionId() ?? -1, tx, changeReason);
-        this._cursorPosition.set(this.editor.getPosition() ?? ( new Position(1, 1)), tx);
+        this._positions.set(this.editor.getSelections()?.map(selection => selection.getPosition()) ?? [( new Position(1, 1))], tx);
     }
     shouldShowHoverAt(range) {
-        const ghostText = this.model.get()?.ghostText.get();
+        const ghostText = this.model.get()?.primaryGhostText.get();
         if (ghostText) {
             return ( ghostText.parts.some(p => range.containsPosition(( new Position(ghostText.lineNumber, p.column)))));
         }
         return false;
     }
     shouldShowHoverAtViewZone(viewZoneId) {
-        return this._ghostTextWidget.ownsViewZone(viewZoneId);
+        return this._ghostTextWidgets.get()[0]?.ownsViewZone(viewZoneId) ?? false;
     }
     hide() {
         transaction(tx => {
@@ -234,7 +241,27 @@ InlineCompletionsController = InlineCompletionsController_1 = ( __decorate([
     ( __param(4, ICommandService)),
     ( __param(5, ILanguageFeatureDebounceService)),
     ( __param(6, ILanguageFeaturesService)),
-    ( __param(7, IAudioCueService)),
+    ( __param(7, IAccessibilitySignalService)),
     ( __param(8, IKeybindingService))
 ], InlineCompletionsController));
+function convertItemsToStableObservables(items, store) {
+    const result = observableValue('result', []);
+    const innerObservables = [];
+    store.add(autorun(reader => {
+        const itemsValue = items.read(reader);
+        transaction(tx => {
+            if (itemsValue.length !== innerObservables.length) {
+                innerObservables.length = itemsValue.length;
+                for (let i = 0; i < innerObservables.length; i++) {
+                    if (!innerObservables[i]) {
+                        innerObservables[i] = observableValue('item', itemsValue[i]);
+                    }
+                }
+                result.set([...innerObservables], tx);
+            }
+            innerObservables.forEach((o, i) => o.set(itemsValue[i], tx));
+        });
+    }));
+    return result;
+}
 export { InlineCompletionsController };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsHintsWidget.js

@@ -37,7 +37,7 @@ let InlineCompletionsHintsWidget = class InlineCompletionsHintsWidget extends Di
         this.alwaysShowToolbar = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(62 ).showToolbar === 'always');
         this.sessionPosition = undefined;
         this.position = derived(this, reader => {
-            const ghostText = this.model.read(reader)?.ghostText.read(reader);
+            const ghostText = this.model.read(reader)?.primaryGhostText.read(reader);
             if (!this.alwaysShowToolbar.read(reader) || !ghostText || ghostText.parts.length === 0) {
                 this.sessionPosition = undefined;
                 return null;

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

@@ -1,22 +1,25 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { mapFindFirst } from '../../../../base/common/arraysFind.js';
-import { BugIndicatingError, onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { BugIndicatingError, onUnexpectedExternalError, onUnexpectedError } from '../../../../base/common/errors.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
+import { commonPrefixLength, splitLinesIncludeSeparators } from '../../../../base/common/strings.js';
 import { isDefined } from '../../../../base/common/types.js';
 import { EditOperation } from '../../../common/core/editOperation.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
 import { InlineCompletionTriggerKind } from '../../../common/languages.js';
 import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
-import { GhostText, ghostTextOrReplacementEquals } from './ghostText.js';
+import { GhostText, ghostTextsOrReplacementsEqual, ghostTextOrReplacementEquals } from './ghostText.js';
 import { InlineCompletionsSource } from './inlineCompletionsSource.js';
-import { lengthOfText, addPositions } from './utils.js';
+import { SingleTextEdit } from './singleTextEdit.js';
+import { addPositions, lengthOfText, subtractPositions, Permutation, getNewRanges } from './utils.js';
 import { SnippetController2 } from '../../snippet/browser/snippetController2.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { observableValue, subtransaction, transaction } from '../../../../base/common/observableInternal/base.js';
 import { observableSignal, recomputeInitiallyAndOnChange } from '../../../../base/common/observableInternal/utils.js';
-import { derivedHandleChanges, derived, derivedOpts } from '../../../../base/common/observableInternal/derived.js';
+import { derived, derivedHandleChanges, derivedOpts } from '../../../../base/common/observableInternal/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/autorun.js';
 var VersionIdChangeReason;
 ( (function(VersionIdChangeReason) {
@@ -27,12 +30,12 @@ var VersionIdChangeReason;
 })(VersionIdChangeReason || (VersionIdChangeReason = {})));
 let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
     get isAcceptingPartially() { return this._isAcceptingPartially; }
-    constructor(textModel, selectedSuggestItem, cursorPosition, textModelVersionId, _debounceValue, _suggestPreviewEnabled, _suggestPreviewMode, _inlineSuggestMode, _enabled, _instantiationService, _commandService, _languageConfigurationService) {
+    constructor(textModel, selectedSuggestItem, textModelVersionId, _positions, _debounceValue, _suggestPreviewEnabled, _suggestPreviewMode, _inlineSuggestMode, _enabled, _instantiationService, _commandService, _languageConfigurationService) {
         super();
         this.textModel = textModel;
         this.selectedSuggestItem = selectedSuggestItem;
-        this.cursorPosition = cursorPosition;
         this.textModelVersionId = textModelVersionId;
+        this._positions = _positions;
         this._debounceValue = _debounceValue;
         this._suggestPreviewEnabled = _suggestPreviewEnabled;
         this._suggestPreviewMode = _suggestPreviewMode;
@@ -45,6 +48,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         this._isActive = observableValue(this, false);
         this._forceUpdateSignal = observableSignal('forceUpdate');
         this._selectedInlineCompletionId = observableValue(this, undefined);
+        this._primaryPosition = derived(this, reader => this._positions.read(reader)[0] ?? ( new Position(1, 1)));
         this._isAcceptingPartially = false;
         this._preserveCurrentCompletionReasons = ( new Set([
             VersionIdChangeReason.Redo,
@@ -88,7 +92,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                     this._source.clearSuggestWidgetInlineCompletions(tx);
                 });
             }
-            const cursorPosition = this.cursorPosition.read(reader);
+            const cursorPosition = this._primaryPosition.read(reader);
             const context = {
                 triggerKind: changeSummary.inlineCompletionTriggerKind,
                 selectedSuggestionInfo: suggestItem?.toSelectedSuggestionInfo(),
@@ -100,7 +104,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (!c) {
                 return [];
             }
-            const cursorPosition = this.cursorPosition.read(reader);
+            const cursorPosition = this._primaryPosition.read(reader);
             const filteredCompletions = c.inlineCompletions.filter(c => c.isVisible(this.textModel, cursorPosition, reader));
             return filteredCompletions;
         });
@@ -135,7 +139,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
                 if (!a || !b) {
                     return a === b;
                 }
-                return ghostTextOrReplacementEquals(a.ghostText, b.ghostText)
+                return ghostTextsOrReplacementsEqual(a.ghostTexts, b.ghostTexts)
                     && a.inlineCompletion === b.inlineCompletion
                     && a.suggestItem === b.suggestItem;
             }
@@ -143,36 +147,57 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             const model = this.textModel;
             const suggestItem = this.selectedSuggestItem.read(reader);
             if (suggestItem) {
-                const suggestCompletion = suggestItem.toSingleTextEdit().removeCommonPrefix(model);
-                const augmentedCompletion = this._computeAugmentedCompletion(suggestCompletion, reader);
+                const suggestCompletionEdit = suggestItem.toSingleTextEdit().removeCommonPrefix(model);
+                const augmentation = this._computeAugmentation(suggestCompletionEdit, reader);
                 const isSuggestionPreviewEnabled = this._suggestPreviewEnabled.read(reader);
-                if (!isSuggestionPreviewEnabled && !augmentedCompletion) {
+                if (!isSuggestionPreviewEnabled && !augmentation) {
                     return undefined;
                 }
-                const edit = augmentedCompletion?.edit ?? suggestCompletion;
-                const editPreviewLength = augmentedCompletion ? augmentedCompletion.edit.text.length - suggestCompletion.text.length : 0;
+                const fullEdit = augmentation?.edit ?? suggestCompletionEdit;
+                const fullEditPreviewLength = augmentation ? augmentation.edit.text.length - suggestCompletionEdit.text.length : 0;
                 const mode = this._suggestPreviewMode.read(reader);
-                const cursor = this.cursorPosition.read(reader);
-                const newGhostText = edit.computeGhostText(model, mode, cursor, editPreviewLength);
-                const ghostText = newGhostText ?? ( new GhostText(edit.range.endLineNumber, []));
-                return { ghostText, inlineCompletion: augmentedCompletion?.completion, suggestItem };
+                const positions = this._positions.read(reader);
+                const edits = [fullEdit, ...getSecondaryEdits(this.textModel, positions, fullEdit)];
+                const ghostTexts = ( edits
+                    .map(
+                    (edit, idx) => edit.computeGhostText(model, mode, positions[idx], fullEditPreviewLength)
+                ))
+                    .filter(isDefined);
+                const primaryGhostText = ghostTexts[0] ?? ( new GhostText(fullEdit.range.endLineNumber, []));
+                return { edits, primaryGhostText, ghostTexts, inlineCompletion: augmentation?.completion, suggestItem };
             }
             else {
                 if (!this._isActive.read(reader)) {
                     return undefined;
                 }
-                const item = this.selectedInlineCompletion.read(reader);
-                if (!item) {
+                const inlineCompletion = this.selectedInlineCompletion.read(reader);
+                if (!inlineCompletion) {
                     return undefined;
                 }
-                const replacement = item.toSingleTextEdit(reader);
+                const replacement = inlineCompletion.toSingleTextEdit(reader);
                 const mode = this._inlineSuggestMode.read(reader);
-                const cursor = this.cursorPosition.read(reader);
-                const ghostText = replacement.computeGhostText(model, mode, cursor);
-                return ghostText ? { ghostText, inlineCompletion: item, suggestItem: undefined } : undefined;
+                const positions = this._positions.read(reader);
+                const edits = [replacement, ...getSecondaryEdits(this.textModel, positions, replacement)];
+                const ghostTexts = ( edits
+                    .map((edit, idx) => edit.computeGhostText(model, mode, positions[idx], 0)))
+                    .filter(isDefined);
+                if (!ghostTexts[0]) {
+                    return undefined;
+                }
+                return { edits, primaryGhostText: ghostTexts[0], ghostTexts, inlineCompletion, suggestItem: undefined };
+            }
+        });
+        this.ghostTexts = derivedOpts({
+            owner: this,
+            equalityComparer: ghostTextsOrReplacementsEqual
+        }, reader => {
+            const v = this.state.read(reader);
+            if (!v) {
+                return undefined;
             }
+            return v.ghostTexts;
         });
-        this.ghostText = derivedOpts({
+        this.primaryGhostText = derivedOpts({
             owner: this,
             equalityComparer: ghostTextOrReplacementEquals
         }, reader => {
@@ -180,7 +205,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             if (!v) {
                 return undefined;
             }
-            return v.ghostText;
+            return v?.primaryGhostText;
         });
         this._register(recomputeInitiallyAndOnChange(this._fetchInlineCompletions));
         let lastItem = undefined;
@@ -214,7 +239,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             this._source.clear(tx);
         });
     }
-    _computeAugmentedCompletion(suggestCompletion, reader) {
+    _computeAugmentation(suggestCompletion, reader) {
         const model = this.textModel;
         const suggestWidgetInlineCompletions = this._source.suggestWidgetInlineCompletions.read(reader);
         const candidateInlineCompletions = suggestWidgetInlineCompletions
@@ -223,7 +248,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
         const augmentedCompletion = mapFindFirst(candidateInlineCompletions, completion => {
             let r = completion.toSingleTextEdit(reader);
             r = r.removeCommonPrefix(model, Range.fromPositions(r.range.getStartPosition(), suggestCompletion.range.getEndPosition()));
-            return r.augments(suggestCompletion) ? { edit: r, completion } : undefined;
+            return r.augments(suggestCompletion) ? { completion, edit: r } : undefined;
         });
         return augmentedCompletion;
     }
@@ -249,7 +274,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             throw new BugIndicatingError();
         }
         const state = this.state.get();
-        if (!state || state.ghostText.isEmpty() || !state.inlineCompletion) {
+        if (!state || state.primaryGhostText.isEmpty() || !state.inlineCompletion) {
             return;
         }
         const completion = state.inlineCompletion.toInlineCompletion(undefined);
@@ -263,10 +288,13 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             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', [
-                EditOperation.replaceMove(completion.range, completion.insertText),
+                ...( edits.map(edit => EditOperation.replaceMove(edit.range, edit.text))),
                 ...completion.additionalTextEdits
             ]);
+            editor.setSelections(selections, 'inlineCompletionAccept');
         }
         if (completion.command) {
             completion.source.addRef();
@@ -324,40 +352,44 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
             throw new BugIndicatingError();
         }
         const state = this.state.get();
-        if (!state || state.ghostText.isEmpty() || !state.inlineCompletion) {
+        if (!state || state.primaryGhostText.isEmpty() || !state.inlineCompletion) {
             return;
         }
-        const ghostText = state.ghostText;
+        const ghostText = state.primaryGhostText;
         const completion = state.inlineCompletion.toInlineCompletion(undefined);
         if (completion.snippetInfo || completion.filterText !== completion.insertText) {
             await this.accept(editor);
             return;
         }
         const firstPart = ghostText.parts[0];
-        const position = ( new Position(ghostText.lineNumber, firstPart.column));
-        const line = firstPart.lines.join('\n');
-        const acceptUntilIndexExclusive = getAcceptUntilIndex(position, line);
-        if (acceptUntilIndexExclusive === line.length && ghostText.parts.length === 1) {
+        const ghostTextPos = ( new Position(ghostText.lineNumber, firstPart.column));
+        const ghostTextVal = firstPart.text;
+        const acceptUntilIndexExclusive = getAcceptUntilIndex(ghostTextPos, ghostTextVal);
+        if (acceptUntilIndexExclusive === ghostTextVal.length && ghostText.parts.length === 1) {
             this.accept(editor);
             return;
         }
-        const partialText = line.substring(0, acceptUntilIndexExclusive);
+        const partialGhostTextVal = ghostTextVal.substring(0, acceptUntilIndexExclusive);
+        const positions = this._positions.get();
+        const cursorPosition = positions[0];
         completion.source.addRef();
         try {
             this._isAcceptingPartially = true;
             try {
                 editor.pushUndoStop();
-                editor.executeEdits('inlineSuggestion.accept', [
-                    EditOperation.replace(Range.fromPositions(position), partialText),
-                ]);
-                const length = lengthOfText(partialText);
-                editor.setPosition(addPositions(position, length), 'inlineCompletionPartialAccept');
+                const replaceRange = Range.fromPositions(cursorPosition, ghostTextPos);
+                const newText = editor.getModel().getValueInRange(replaceRange) + partialGhostTextVal;
+                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.replaceMove(edit.range, edit.text))));
+                editor.setSelections(selections, 'inlineCompletionPartialAccept');
             }
             finally {
                 this._isAcceptingPartially = false;
             }
             if (completion.source.provider.handlePartialAccept) {
-                const acceptedRange = Range.fromPositions(completion.range.getStartPosition(), addPositions(position, lengthOfText(partialText)));
+                const acceptedRange = Range.fromPositions(completion.range.getStartPosition(), addPositions(ghostTextPos, lengthOfText(partialGhostTextVal)));
                 const text = editor.getModel().getValueInRange(acceptedRange, 1 );
                 completion.source.provider.handlePartialAccept(completion.source.inlineCompletions, completion.sourceInlineCompletion, text.length);
             }
@@ -368,7 +400,7 @@ let InlineCompletionsModel = class InlineCompletionsModel extends Disposable {
     }
     handleSuggestAccepted(item) {
         const itemEdit = item.toSingleTextEdit().removeCommonPrefix(this.textModel);
-        const augmentedCompletion = this._computeAugmentedCompletion(itemEdit, undefined);
+        const augmentedCompletion = this._computeAugmentation(itemEdit, undefined);
         if (!augmentedCompletion) {
             return;
         }
@@ -381,4 +413,42 @@ InlineCompletionsModel = ( __decorate([
     ( __param(10, ICommandService)),
     ( __param(11, ILanguageConfigurationService))
 ], InlineCompletionsModel));
-export { InlineCompletionsModel, VersionIdChangeReason };
+function getSecondaryEdits(textModel, positions, primaryEdit) {
+    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 SingleTextEdit(range, secondaryEditText));
+    }));
+}
+function substringPos(text, pos) {
+    let subtext = '';
+    const lines = splitLinesIncludeSeparators(text);
+    for (let i = pos.lineNumber - 1; i < lines.length; i++) {
+        subtext += lines[i].substring(i === pos.lineNumber - 1 ? pos.column - 1 : 0);
+    }
+    return subtext;
+}
+function getEndPositionsAfterApplying(edits) {
+    const sortPerm = Permutation.createSortPermutation(edits, (edit1, edit2) => Range.compareRangesUsingStarts(edit1.range, edit2.range));
+    const sortedNewRanges = getNewRanges(sortPerm.apply(edits));
+    const newRanges = sortPerm.inverse().apply(sortedNewRanges);
+    return ( newRanges.map(range => range.getEndPosition()));
+}
+export { InlineCompletionsModel, VersionIdChangeReason, getSecondaryEdits };

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

@@ -40,7 +40,7 @@ let InlineCompletionsSource = class InlineCompletionsSource extends Disposable {
         const promise = (async () => {
             const shouldDebounce = updateOngoing || context.triggerKind === InlineCompletionTriggerKind.Automatic;
             if (shouldDebounce) {
-                await wait(this._debounceValue.get(this.textModel));
+                await wait(this._debounceValue.get(this.textModel), source.token);
             }
             if (source.token.isCancellationRequested || this.textModel.getVersionId() !== request.versionId) {
                 return false;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/singleTextEdit.js

@@ -1,5 +1,5 @@
 import { LcsDiff } from '../../../../base/common/diff/diff.js';
-import { commonPrefixLength, getLeadingWhitespace, splitLines } from '../../../../base/common/strings.js';
+import { commonPrefixLength, getLeadingWhitespace } from '../../../../base/common/strings.js';
 import { Range } from '../../../common/core/range.js';
 import { GhostTextPart, GhostText } from './ghostText.js';
 import { addPositions, lengthOfText } from './utils.js';
@@ -8,6 +8,9 @@ class SingleTextEdit {
         this.range = range;
         this.text = text;
     }
+    static equals(first, second) {
+        return first.range.equalsRange(second.range) && first.text === second.text;
+    }
     removeCommonPrefix(model, validModelRange) {
         const modelRange = validModelRange ? this.range.intersectRanges(validModelRange) : this.range;
         if (!modelRange) {
@@ -74,12 +77,10 @@ class SingleTextEdit {
             const nonPreviewText = edit.text.substring(c.modifiedStart, nonPreviewTextEnd);
             const italicText = edit.text.substring(nonPreviewTextEnd, Math.max(c.modifiedStart, modifiedEnd));
             if (nonPreviewText.length > 0) {
-                const lines = splitLines(nonPreviewText);
-                parts.push(( new GhostTextPart(insertColumn, lines, false)));
+                parts.push(( new GhostTextPart(insertColumn, nonPreviewText, false)));
             }
             if (italicText.length > 0) {
-                const lines = splitLines(italicText);
-                parts.push(( new GhostTextPart(insertColumn, lines, true)));
+                parts.push(( new GhostTextPart(insertColumn, italicText, true)));
             }
         }
         return ( new GhostText(lineNumber, parts));

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/utils.js

@@ -73,6 +73,12 @@ function addPositions(pos1, pos2) {
         pos2.lineNumber === 1 ? pos1.column + pos2.column - 1 : pos2.column
     ));
 }
+function subtractPositions(pos1, pos2) {
+    return ( new Position(
+        pos1.lineNumber - pos2.lineNumber + 1,
+        pos1.lineNumber - pos2.lineNumber === 0 ? pos1.column - pos2.column + 1 : pos1.column
+    ));
+}
 function lengthOfText(text) {
     let line = 1;
     let column = 1;
@@ -87,4 +93,43 @@ function lengthOfText(text) {
     }
     return ( new Position(line, column));
 }
-export { ColumnRange, addPositions, applyEdits, applyObservableDecorations, getReadonlyEmptyArray, lengthOfText };
+function getNewRanges(edits) {
+    const newRanges = [];
+    let previousEditEndLineNumber = 0;
+    let lineOffset = 0;
+    let columnOffset = 0;
+    for (const edit of edits) {
+        const text = edit.text ?? '';
+        const textLength = lengthOfText(text);
+        const newRangeStart = Position.lift({
+            lineNumber: edit.range.startLineNumber + lineOffset,
+            column: edit.range.startColumn + (edit.range.startLineNumber === previousEditEndLineNumber ? columnOffset : 0)
+        });
+        const newRangeEnd = addPositions(newRangeStart, textLength);
+        newRanges.push(Range.fromPositions(newRangeStart, newRangeEnd));
+        lineOffset += textLength.lineNumber - edit.range.endLineNumber + edit.range.startLineNumber - 1;
+        columnOffset = newRangeEnd.column - edit.range.endColumn;
+        previousEditEndLineNumber = edit.range.endLineNumber;
+    }
+    return newRanges;
+}
+class Permutation {
+    constructor(_indexMap) {
+        this._indexMap = _indexMap;
+    }
+    static createSortPermutation(arr, compareFn) {
+        const sortIndices = Array.from(( arr.keys())).sort((index1, index2) => compareFn(arr[index1], arr[index2]));
+        return ( new Permutation(sortIndices));
+    }
+    apply(arr) {
+        return ( arr.map((_, index) => arr[this._indexMap[index]]));
+    }
+    inverse() {
+        const inverseIndexMap = this._indexMap.slice();
+        for (let i = 0; i < this._indexMap.length; i++) {
+            inverseIndexMap[this._indexMap[i]] = i;
+        }
+        return ( new Permutation(inverseIndexMap));
+    }
+}
+export { ColumnRange, Permutation, addPositions, applyEdits, applyObservableDecorations, getNewRanges, getReadonlyEmptyArray, lengthOfText, subtractPositions };

package/vscode/src/vs/editor/contrib/inlineEdit/browser/commandIds.js

@@ -0,0 +1,5 @@
+const inlineEditAcceptId = 'editor.action.inlineEdit.accept';
+const inlineEditRejectId = 'editor.action.inlineEdit.reject';
+const inlineEditJumpToId = 'editor.action.inlineEdit.jumpTo';
+const inlineEditJumpBackId = 'editor.action.inlineEdit.jumpBack';
+export { inlineEditAcceptId, inlineEditJumpBackId, inlineEditJumpToId, inlineEditRejectId };