monaco-editor-core 0.56.0-dev-20260121 → 0.56.0-dev-20260123

package/esm/vs/editor/contrib/inlineCompletions/browser/controller/commands.js

@@ -25,7 +25,7 @@ export class ShowNextInlineSuggestionAction extends EditorAction {
     constructor() {
         super({
             id: ShowNextInlineSuggestionAction.ID,
-            label: nls.localize2(1190, "Show Next Inline Suggestion"),
+            label: nls.localize2(1192, "Show Next Inline Suggestion"),
             precondition: ContextKeyExpr.and(EditorContextKeys.writable, InlineCompletionContextKeys.inlineSuggestionVisible),
             kbOpts: {
                 weight: 100,
@@ -43,7 +43,7 @@ export class ShowPreviousInlineSuggestionAction extends EditorAction {
     constructor() {
         super({
             id: ShowPreviousInlineSuggestionAction.ID,
-            label: nls.localize2(1191, "Show Previous Inline Suggestion"),
+            label: nls.localize2(1193, "Show Previous Inline Suggestion"),
             precondition: ContextKeyExpr.and(EditorContextKeys.writable, InlineCompletionContextKeys.inlineSuggestionVisible),
             kbOpts: {
                 weight: 100,
@@ -75,13 +75,13 @@ export class TriggerInlineSuggestionAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inlineSuggest.trigger',
-            label: nls.localize2(1192, "Trigger Inline Suggestion"),
+            label: nls.localize2(1194, "Trigger Inline Suggestion"),
             precondition: EditorContextKeys.writable,
             metadata: {
-                description: nls.localize(1179, "Triggers an inline suggestion in the editor."),
+                description: nls.localize(1181, "Triggers an inline suggestion in the editor."),
                 args: [{
                         name: 'args',
-                        description: nls.localize(1180, "Options for triggering inline suggestions."),
+                        description: nls.localize(1182, "Options for triggering inline suggestions."),
                         isOptional: true,
                         schema: argsValidator.getJSONSchema(),
                     }]
@@ -110,7 +110,7 @@ export class TriggerInlineSuggestionAction extends EditorAction {
             if (!controller?.model.get()?.state.get()) {
                 notificationService.notify({
                     severity: Severity.Info,
-                    message: nls.localize(1181, "No inline suggestion is available.")
+                    message: nls.localize(1183, "No inline suggestion is available.")
                 });
             }
         }
@@ -120,7 +120,7 @@ export class AcceptNextWordOfInlineCompletion extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inlineSuggest.acceptNextWord',
-            label: nls.localize2(1193, "Accept Next Word Of Inline Suggestion"),
+            label: nls.localize2(1195, "Accept Next Word Of Inline Suggestion"),
             precondition: ContextKeyExpr.and(EditorContextKeys.writable, InlineCompletionContextKeys.inlineSuggestionVisible),
             kbOpts: {
                 weight: 100 /* KeybindingWeight.EditorContrib */ + 1,
@@ -129,7 +129,7 @@ export class AcceptNextWordOfInlineCompletion extends EditorAction {
             },
             menuOpts: [{
                     menuId: MenuId.InlineSuggestionToolbar,
-                    title: nls.localize(1182, 'Accept Word'),
+                    title: nls.localize(1184, 'Accept Word'),
                     group: 'primary',
                     order: 2,
                 }],
@@ -144,14 +144,14 @@ export class AcceptNextLineOfInlineCompletion extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inlineSuggest.acceptNextLine',
-            label: nls.localize2(1194, "Accept Next Line Of Inline Suggestion"),
+            label: nls.localize2(1196, "Accept Next Line Of Inline Suggestion"),
             precondition: ContextKeyExpr.and(EditorContextKeys.writable, InlineCompletionContextKeys.inlineSuggestionVisible),
             kbOpts: {
                 weight: 100 /* KeybindingWeight.EditorContrib */ + 1,
             },
             menuOpts: [{
                     menuId: MenuId.InlineSuggestionToolbar,
-                    title: nls.localize(1183, 'Accept Line'),
+                    title: nls.localize(1185, 'Accept Line'),
                     group: 'secondary',
                     order: 2,
                 }],
@@ -166,16 +166,16 @@ export class AcceptInlineCompletion extends EditorAction {
     constructor() {
         super({
             id: inlineSuggestCommitId,
-            label: nls.localize2(1195, "Accept Inline Suggestion"),
+            label: nls.localize2(1197, "Accept Inline Suggestion"),
             precondition: ContextKeyExpr.or(InlineCompletionContextKeys.inlineSuggestionVisible, InlineCompletionContextKeys.inlineEditVisible),
             menuOpts: [{
                     menuId: MenuId.InlineSuggestionToolbar,
-                    title: nls.localize(1184, "Accept"),
+                    title: nls.localize(1186, "Accept"),
                     group: 'primary',
                     order: 2,
                 }, {
                     menuId: MenuId.InlineEditsActions,
-                    title: nls.localize(1185, "Accept"),
+                    title: nls.localize(1187, "Accept"),
                     group: 'primary',
                     order: 2,
                 }],
@@ -206,7 +206,7 @@ export class AcceptInlineCompletionAlternativeAction extends EditorAction {
     constructor() {
         super({
             id: inlineSuggestCommitAlternativeActionId,
-            label: nls.localize2(1196, "Accept Inline Suggestion Alternative Action"),
+            label: nls.localize2(1198, "Accept Inline Suggestion Alternative Action"),
             precondition: ContextKeyExpr.and(InlineCompletionContextKeys.inlineSuggestionAlternativeActionVisible, InlineCompletionContextKeys.inlineEditVisible),
             menuOpts: [],
             kbOpts: [
@@ -235,11 +235,11 @@ export class JumpToNextInlineEdit extends EditorAction {
     constructor() {
         super({
             id: jumpToNextInlineEditId,
-            label: nls.localize2(1197, "Jump to next inline edit"),
+            label: nls.localize2(1199, "Jump to next inline edit"),
             precondition: InlineCompletionContextKeys.inlineEditVisible,
             menuOpts: [{
                     menuId: MenuId.InlineEditsActions,
-                    title: nls.localize(1186, "Jump"),
+                    title: nls.localize(1188, "Jump"),
                     group: 'primary',
                     order: 1,
                     when: InlineCompletionContextKeys.cursorAtInlineEdit.toNegated(),
@@ -263,7 +263,7 @@ export class HideInlineCompletion extends EditorAction {
     constructor() {
         super({
             id: HideInlineCompletion.ID,
-            label: nls.localize2(1198, "Hide Inline Suggestion"),
+            label: nls.localize2(1200, "Hide Inline Suggestion"),
             precondition: ContextKeyExpr.or(InlineCompletionContextKeys.inlineSuggestionVisible, InlineCompletionContextKeys.inlineEditVisible),
             kbOpts: {
                 weight: 100 /* KeybindingWeight.EditorContrib */ + 90, // same as hiding the suggest widget
@@ -271,7 +271,7 @@ export class HideInlineCompletion extends EditorAction {
             },
             menuOpts: [{
                     menuId: MenuId.InlineEditsActions,
-                    title: nls.localize(1187, "Reject"),
+                    title: nls.localize(1189, "Reject"),
                     group: 'primary',
                     order: 3,
                 }]
@@ -290,7 +290,7 @@ export class ToggleInlineCompletionShowCollapsed extends EditorAction {
     constructor() {
         super({
             id: ToggleInlineCompletionShowCollapsed.ID,
-            label: nls.localize2(1199, "Toggle Inline Suggestions Show Collapsed"),
+            label: nls.localize2(1201, "Toggle Inline Suggestions Show Collapsed"),
             precondition: ContextKeyExpr.true(),
         });
     }
@@ -312,7 +312,7 @@ export class ToggleAlwaysShowInlineSuggestionToolbar extends Action2 {
     constructor() {
         super({
             id: ToggleAlwaysShowInlineSuggestionToolbar.ID,
-            title: nls.localize(1188, "Always Show Toolbar"),
+            title: nls.localize(1190, "Always Show Toolbar"),
             f1: false,
             precondition: undefined,
             menu: [{
@@ -334,7 +334,7 @@ export class DevExtractReproSample extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inlineSuggest.dev.extractRepro',
-            label: nls.localize(1189, "Developer: Extract Inline Suggest State"),
+            label: nls.localize(1191, "Developer: Extract Inline Suggest State"),
             alias: 'Developer: Inline Suggest Extract Repro',
             precondition: ContextKeyExpr.or(InlineCompletionContextKeys.inlineEditVisible, InlineCompletionContextKeys.inlineSuggestionVisible),
         });

package/esm/vs/editor/contrib/inlineCompletions/browser/controller/inlineCompletionContextKeys.js

@@ -6,18 +6,18 @@ import { RawContextKey } from '../../../../../platform/contextkey/common/context
 import { localize } from '../../../../../nls.js';
 import * as nls from '../../../../../nls.js';
 export class InlineCompletionContextKeys {
-    static { this.inlineSuggestionVisible = new RawContextKey('inlineSuggestionVisible', false, localize(1200, "Whether an inline suggestion is visible")); }
-    static { this.inlineSuggestionAlternativeActionVisible = new RawContextKey('inlineSuggestionAlternativeActionVisible', false, localize(1201, "Whether an alternative action for the inline suggestion is visible.")); }
-    static { this.inlineSuggestionHasIndentation = new RawContextKey('inlineSuggestionHasIndentation', false, localize(1202, "Whether the inline suggestion starts with whitespace")); }
-    static { this.inlineSuggestionHasIndentationLessThanTabSize = new RawContextKey('inlineSuggestionHasIndentationLessThanTabSize', true, localize(1203, "Whether the inline suggestion starts with whitespace that is less than what would be inserted by tab")); }
-    static { this.suppressSuggestions = new RawContextKey('inlineSuggestionSuppressSuggestions', undefined, localize(1204, "Whether suggestions should be suppressed for the current suggestion")); }
-    static { this.cursorBeforeGhostText = new RawContextKey('cursorBeforeGhostText', false, localize(1205, "Whether the cursor is at ghost text")); }
-    static { this.cursorInIndentation = new RawContextKey('cursorInIndentation', false, localize(1206, "Whether the cursor is in indentation")); }
-    static { this.hasSelection = new RawContextKey('editor.hasSelection', false, localize(1207, "Whether the editor has a selection")); }
-    static { this.cursorAtInlineEdit = new RawContextKey('cursorAtInlineEdit', false, localize(1208, "Whether the cursor is at an inline edit")); }
-    static { this.inlineEditVisible = new RawContextKey('inlineEditIsVisible', false, localize(1209, "Whether an inline edit is visible")); }
-    static { this.tabShouldJumpToInlineEdit = new RawContextKey('tabShouldJumpToInlineEdit', false, localize(1210, "Whether tab should jump to an inline edit.")); }
-    static { this.tabShouldAcceptInlineEdit = new RawContextKey('tabShouldAcceptInlineEdit', false, localize(1211, "Whether tab should accept the inline edit.")); }
-    static { this.inInlineEditsPreviewEditor = new RawContextKey('inInlineEditsPreviewEditor', true, nls.localize(1212, "Whether the current code editor is showing an inline edits preview")); }
+    static { this.inlineSuggestionVisible = new RawContextKey('inlineSuggestionVisible', false, localize(1202, "Whether an inline suggestion is visible")); }
+    static { this.inlineSuggestionAlternativeActionVisible = new RawContextKey('inlineSuggestionAlternativeActionVisible', false, localize(1203, "Whether an alternative action for the inline suggestion is visible.")); }
+    static { this.inlineSuggestionHasIndentation = new RawContextKey('inlineSuggestionHasIndentation', false, localize(1204, "Whether the inline suggestion starts with whitespace")); }
+    static { this.inlineSuggestionHasIndentationLessThanTabSize = new RawContextKey('inlineSuggestionHasIndentationLessThanTabSize', true, localize(1205, "Whether the inline suggestion starts with whitespace that is less than what would be inserted by tab")); }
+    static { this.suppressSuggestions = new RawContextKey('inlineSuggestionSuppressSuggestions', undefined, localize(1206, "Whether suggestions should be suppressed for the current suggestion")); }
+    static { this.cursorBeforeGhostText = new RawContextKey('cursorBeforeGhostText', false, localize(1207, "Whether the cursor is at ghost text")); }
+    static { this.cursorInIndentation = new RawContextKey('cursorInIndentation', false, localize(1208, "Whether the cursor is in indentation")); }
+    static { this.hasSelection = new RawContextKey('editor.hasSelection', false, localize(1209, "Whether the editor has a selection")); }
+    static { this.cursorAtInlineEdit = new RawContextKey('cursorAtInlineEdit', false, localize(1210, "Whether the cursor is at an inline edit")); }
+    static { this.inlineEditVisible = new RawContextKey('inlineEditIsVisible', false, localize(1211, "Whether an inline edit is visible")); }
+    static { this.tabShouldJumpToInlineEdit = new RawContextKey('tabShouldJumpToInlineEdit', false, localize(1212, "Whether tab should jump to an inline edit.")); }
+    static { this.tabShouldAcceptInlineEdit = new RawContextKey('tabShouldAcceptInlineEdit', false, localize(1213, "Whether tab should accept the inline edit.")); }
+    static { this.inInlineEditsPreviewEditor = new RawContextKey('inInlineEditsPreviewEditor', true, nls.localize(1214, "Whether the current code editor is showing an inline edits preview")); }
 }
 //# sourceMappingURL=inlineCompletionContextKeys.js.map

package/esm/vs/editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController.js

@@ -378,7 +378,7 @@ let InlineCompletionsController = class InlineCompletionsController extends Disp
         const accessibleViewKeybinding = this._keybindingService.lookupKeybinding('editor.action.accessibleView');
         let hint;
         if (!accessibleViewShowing && accessibleViewKeybinding && this.editor.getOption(169 /* EditorOption.inlineCompletionsAccessibilityVerbose */)) {
-            hint = localize(1213, "Inspect this in the accessible view ({0})", accessibleViewKeybinding.getAriaLabel());
+            hint = localize(1215, "Inspect this in the accessible view ({0})", accessibleViewKeybinding.getAriaLabel());
         }
         alert(hint ? content + ', ' + hint : content);
     }

package/esm/vs/editor/contrib/inlineCompletions/browser/hintsWidget/hoverParticipant.js

@@ -115,7 +115,7 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
         return new RenderedHoverParts([renderedHoverPart]);
     }
     getAccessibleContent(hoverPart) {
-        return nls.localize(1214, 'There are inline completions here');
+        return nls.localize(1216, 'There are inline completions here');
     }
     renderScreenReaderText(context, part) {
         const disposables = new DisposableStore();
@@ -123,7 +123,7 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
         const markdownHoverElement = $('div.hover-row.markdown-hover');
         const hoverContentsElement = dom.append(markdownHoverElement, $('div.hover-contents', { ['aria-live']: 'assertive' }));
         const render = (code) => {
-            const inlineSuggestionAvailable = nls.localize(1215, "Suggestion:");
+            const inlineSuggestionAvailable = nls.localize(1217, "Suggestion:");
             const renderedContents = disposables.add(this._markdownRendererService.render(new MarkdownString().appendText(inlineSuggestionAvailable).appendCodeblock('text', code), {
                 context: this._editor,
                 asyncRenderCallback: () => {

package/esm/vs/editor/contrib/inlineCompletions/browser/hintsWidget/inlineCompletionsHintsWidget.js

@@ -97,8 +97,8 @@ InlineCompletionsHintsWidget = __decorate([
     __param(2, IInstantiationService)
 ], InlineCompletionsHintsWidget);
 export { InlineCompletionsHintsWidget };
-const inlineSuggestionHintsNextIcon = registerIcon('inline-suggestion-hints-next', Codicon.chevronRight, localize(1216, 'Icon for show next parameter hint.'));
-const inlineSuggestionHintsPreviousIcon = registerIcon('inline-suggestion-hints-previous', Codicon.chevronLeft, localize(1217, 'Icon for show previous parameter hint.'));
+const inlineSuggestionHintsNextIcon = registerIcon('inline-suggestion-hints-next', Codicon.chevronRight, localize(1218, 'Icon for show next parameter hint.'));
+const inlineSuggestionHintsPreviousIcon = registerIcon('inline-suggestion-hints-previous', Codicon.chevronLeft, localize(1219, 'Icon for show previous parameter hint.'));
 let InlineSuggestionHintsContentWidget = class InlineSuggestionHintsContentWidget extends Disposable {
     static { InlineSuggestionHintsContentWidget_1 = this; }
     static { this.hot = createHotClass(this); }
@@ -153,9 +153,9 @@ let InlineSuggestionHintsContentWidget = class InlineSuggestionHintsContentWidge
             this._warningMessageNode.element,
             h('div@toolBar'),
         ]);
-        this.previousAction = this._register(this.createCommandAction(showPreviousInlineSuggestionActionId, localize(1218, 'Previous'), ThemeIcon.asClassName(inlineSuggestionHintsPreviousIcon)));
+        this.previousAction = this._register(this.createCommandAction(showPreviousInlineSuggestionActionId, localize(1220, 'Previous'), ThemeIcon.asClassName(inlineSuggestionHintsPreviousIcon)));
         this.availableSuggestionCountAction = this._register(new Action('inlineSuggestionHints.availableSuggestionCount', '', undefined, false));
-        this.nextAction = this._register(this.createCommandAction(showNextInlineSuggestionActionId, localize(1219, 'Next'), ThemeIcon.asClassName(inlineSuggestionHintsNextIcon)));
+        this.nextAction = this._register(this.createCommandAction(showNextInlineSuggestionActionId, localize(1221, 'Next'), ThemeIcon.asClassName(inlineSuggestionHintsNextIcon)));
         this.inlineCompletionsActionsMenus = this._register(this._menuService.createMenu(MenuId.InlineCompletionsActions, this._contextKeyService));
         this.clearAvailableSuggestionCountLabelDebounced = this._register(new RunOnceScheduler(() => {
             this.availableSuggestionCountAction.label = '';

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

@@ -17,7 +17,7 @@ import { LcsDiff, StringDiffSequence } from '../../../../../base/common/diff/dif
 import { Disposable } from '../../../../../base/common/lifecycle.js';
 import { localize } from '../../../../../nls.js';
 import { CommandsRegistry, ICommandService } from '../../../../../platform/commands/common/commands.js';
-import { IBulkEditService } from '../../../../browser/services/bulkEditService.js';
+import { IBulkEditService, ResourceTextEdit } from '../../../../browser/services/bulkEditService.js';
 import { TextReplacement } from '../../../../common/core/edits/textEdit.js';
 import { Position } from '../../../../common/core/position.js';
 import { Range } from '../../../../common/core/range.js';
@@ -28,6 +28,8 @@ import { hasProvider, rawRename } from '../../../rename/browser/rename.js';
 import { renameSymbolCommandId } from '../controller/commandIds.js';
 import { InlineSuggestionItem } from './inlineSuggestionItem.js';
 import { Codicon } from '../../../../../base/common/codicons.js';
+import { IRenameSymbolTrackerService } from '../../../../browser/services/renameSymbolTrackerService.js';
+import { ICodeEditorService } from '../../../../browser/services/codeEditorService.js';
 var RenameKind;
 (function (RenameKind) {
     RenameKind["no"] = "no";
@@ -238,16 +240,50 @@ export class RenameInferenceEngine {
         };
     }
 }
+class EditorState {
+    static create(codeEditorService, textModel) {
+        const editor = codeEditorService.getFocusedCodeEditor();
+        if (editor === null) {
+            return undefined;
+        }
+        if (editor.getModel() !== textModel) {
+            return undefined;
+        }
+        return new EditorState(editor, textModel.getVersionId());
+    }
+    constructor(editor, versionId) {
+        this.editor = editor;
+        this.versionId = versionId;
+    }
+    equals(other) {
+        if (other === undefined) {
+            return false;
+        }
+        return this.editor === other.editor && this.versionId === other.versionId;
+    }
+}
 class RenameSymbolRunnable {
-    constructor(languageFeaturesService, textModel, position, newName, requestUuid) {
+    constructor(languageFeaturesService, commandService, requestUuid, textModel, state, position, newName, lastSymbolRename, oldName) {
         this._result = undefined;
+        this._commandService = commandService;
+        this._textModel = textModel;
+        this._state = state;
         this._requestUuid = requestUuid;
         this._cancellationTokenSource = new CancellationTokenSource();
-        this._promise = rawRename(languageFeaturesService.renameProvider, textModel, position, newName, this._cancellationTokenSource.token);
+        if (lastSymbolRename === undefined || oldName === undefined) {
+            this._promise = rawRename(languageFeaturesService.renameProvider, textModel, position, newName, this._cancellationTokenSource.token);
+            return;
+        }
+        else {
+            this._promise = this.sendNesRenameRequest(textModel, position, oldName, newName, lastSymbolRename);
+        }
     }
     get requestUuid() {
         return this._requestUuid;
     }
+    isValid(codeEditorService) {
+        return this._state.equals(EditorState.create(codeEditorService, this._textModel));
+    }
     cancel() {
         this._cancellationTokenSource.cancel();
     }
@@ -276,17 +312,39 @@ class RenameSymbolRunnable {
         }
         return this._result;
     }
+    async sendNesRenameRequest(textModel, position, oldName, newName, lastSymbolRename) {
+        try {
+            const result = await this._commandService.executeCommand('github.copilot.nes.postRename', textModel.uri, position, oldName, newName, lastSymbolRename);
+            if (result === undefined) {
+                return { rejectReason: 'Rename failed', edits: [] };
+            }
+            const edits = [];
+            for (const item of result) {
+                for (const change of item.changes) {
+                    const range = new Range(change.range.start.line + 1, change.range.start.character + 1, change.range.end.line + 1, change.range.end.character + 1);
+                    const edit = new ResourceTextEdit(item.file, new TextReplacement(range, change.newText ?? newName));
+                    edits.push(edit);
+                }
+            }
+            return { edits };
+        }
+        catch (error) {
+            return { rejectReason: 'Rename failed', edits: [] };
+        }
+    }
 }
 let RenameSymbolProcessor = class RenameSymbolProcessor extends Disposable {
-    constructor(_commandService, _languageFeaturesService, _languageConfigurationService, bulkEditService) {
+    constructor(_commandService, _languageFeaturesService, _languageConfigurationService, bulkEditService, _renameSymbolTrackerService, _codeEditorService) {
         super();
         this._commandService = _commandService;
         this._languageFeaturesService = _languageFeaturesService;
         this._languageConfigurationService = _languageConfigurationService;
+        this._renameSymbolTrackerService = _renameSymbolTrackerService;
+        this._codeEditorService = _codeEditorService;
         this._renameInferenceEngine = new RenameInferenceEngine();
         this._renameRunnable = undefined;
         this._register(CommandsRegistry.registerCommand(renameSymbolCommandId, async (_, source, renameRunnable) => {
-            if (renameRunnable === undefined) {
+            if (renameRunnable === undefined || !renameRunnable.isValid(this._codeEditorService)) {
                 return;
             }
             try {
@@ -310,6 +368,10 @@ let RenameSymbolProcessor = class RenameSymbolProcessor extends Disposable {
         if (!hasProvider(this._languageFeaturesService.renameProvider, textModel)) {
             return suggestItem;
         }
+        const state = EditorState.create(this._codeEditorService, textModel);
+        if (state === undefined) {
+            return suggestItem;
+        }
         const start = Date.now();
         const edit = suggestItem.action.textReplacement;
         const languageConfiguration = this._languageConfigurationService.getLanguageConfiguration(textModel.getLanguageId());
@@ -319,10 +381,15 @@ let RenameSymbolProcessor = class RenameSymbolProcessor extends Disposable {
             return suggestItem;
         }
         const { oldName, newName, position, edits: renameEdits } = edits.renames;
+        const trackedWord = this._renameSymbolTrackerService.trackedWord.get();
+        let lastSymbolRename = undefined;
+        if (trackedWord !== undefined && trackedWord.model === textModel && trackedWord.originalWord === oldName && trackedWord.currentWord === newName) {
+            lastSymbolRename = trackedWord.currentRange;
+        }
         // Check asynchronously if a rename is possible
         let timedOut = false;
-        const check = await raceTimeout(this.checkRenamePrecondition(suggestItem, textModel, position, oldName, newName), 100, () => { timedOut = true; });
-        const renamePossible = this.isRenamePossible(suggestItem, check);
+        const check = await raceTimeout(this.checkRenamePrecondition(suggestItem, textModel, position, oldName, newName, lastSymbolRename), 100, () => { timedOut = true; });
+        const renamePossible = this.isRenamePossible(suggestItem, check, state, textModel);
         suggestItem.setRenameProcessingInfo({
             createdRename: renamePossible,
             duration: Date.now() - start,
@@ -335,7 +402,7 @@ let RenameSymbolProcessor = class RenameSymbolProcessor extends Disposable {
         }
         // Prepare the rename edits
         if (this._renameRunnable === undefined) {
-            this._renameRunnable = new RenameSymbolRunnable(this._languageFeaturesService, textModel, position, newName, suggestItem.requestUuid);
+            this._renameRunnable = new RenameSymbolRunnable(this._languageFeaturesService, this._commandService, suggestItem.requestUuid, textModel, state, position, newName, lastSymbolRename, lastSymbolRename !== undefined ? oldName : undefined);
         }
         // Create alternative action
         const source = EditSources.inlineCompletionAccept({
@@ -347,11 +414,11 @@ let RenameSymbolProcessor = class RenameSymbolProcessor extends Disposable {
         });
         const command = {
             id: renameSymbolCommandId,
-            title: localize(1220, "Rename"),
+            title: localize(1222, "Rename"),
             arguments: [source, this._renameRunnable],
         };
         const alternativeAction = {
-            label: localize(1221, "Rename"),
+            label: localize(1223, "Rename"),
             icon: Codicon.replaceAll,
             command,
             count: this._renameRunnable.getCount(),
@@ -366,22 +433,42 @@ let RenameSymbolProcessor = class RenameSymbolProcessor extends Disposable {
         };
         return InlineSuggestionItem.create(suggestItem.withAction(renameAction), textModel, false);
     }
-    async checkRenamePrecondition(suggestItem, textModel, position, oldName, newName) {
+    async checkRenamePrecondition(suggestItem, textModel, position, oldName, newName, lastSymbolRename) {
+        const no = { canRename: RenameKind.no, timedOut: false };
         try {
-            const result = await this._commandService.executeCommand('github.copilot.nes.prepareRename', textModel.uri, position, oldName, newName, suggestItem.requestUuid);
+            const result = await this._commandService.executeCommand('github.copilot.nes.prepareRename', textModel.uri, position, oldName, newName, suggestItem.requestUuid, lastSymbolRename);
             if (result === undefined) {
-                return RenameKind.no;
+                return no;
+            }
+            else if (typeof result === 'string') {
+                const canRename = RenameKind.fromString(result);
+                if (canRename === RenameKind.yes || canRename === RenameKind.maybe) {
+                    return {
+                        canRename,
+                        oldName,
+                        onOldState: false,
+                    };
+                }
+                else {
+                    return {
+                        canRename,
+                        timedOut: false,
+                    };
+                }
             }
             else {
-                return RenameKind.fromString(result);
+                return result;
             }
         }
         catch (error) {
-            return RenameKind.no;
+            return no;
         }
     }
-    isRenamePossible(suggestItem, check) {
-        if (check === undefined || check === RenameKind.no) {
+    isRenamePossible(suggestItem, check, state, textModel) {
+        if (check === undefined || check.canRename === RenameKind.no) {
+            return false;
+        }
+        if (!state.equals(EditorState.create(this._codeEditorService, textModel))) {
             return false;
         }
         if (this._renameRunnable === undefined) {
@@ -401,7 +488,9 @@ RenameSymbolProcessor = __decorate([
     __param(0, ICommandService),
     __param(1, ILanguageFeaturesService),
     __param(2, ILanguageConfigurationService),
-    __param(3, IBulkEditService)
+    __param(3, IBulkEditService),
+    __param(4, IRenameSymbolTrackerService),
+    __param(5, ICodeEditorService)
 ], RenameSymbolProcessor);
 export { RenameSymbolProcessor };
 //# sourceMappingURL=renameSymbolProcessor.js.map