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

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

@@ -4,7 +4,7 @@ import { LcsDiff, StringDiffSequence } from '../../../../../base/common/diff/dif
 import { Disposable } from '../../../../../base/common/lifecycle.js';
 import { localize } from '../../../../../nls.js';
 import { ICommandService, CommandsRegistry } 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';
@@ -15,6 +15,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';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -239,16 +241,50 @@ 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();
     }
@@ -277,17 +313,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 {
@@ -311,6 +369,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());
@@ -320,10 +382,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,
@@ -336,7 +403,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({
@@ -348,11 +415,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(),
@@ -367,22 +434,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) {
@@ -402,7 +489,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 { RenameInferenceEngine, RenameSymbolProcessor };

package/esm/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/components/gutterIndicatorMenu.js

@@ -78,13 +78,13 @@ let GutterIndicatorMenuContent = class GutterIndicatorMenuContent {
         const title = header(this._data.displayName);
         const gotoAndAccept = option(createOptionArgs({
             id: 'gotoAndAccept',
-            title: `${localize(1222, "Go To")} / ${localize(1223, "Accept")}`,
+            title: `${localize(1224, "Go To")} / ${localize(1225, "Accept")}`,
             icon: Codicon.check,
             commandId: inlineSuggestCommitId,
         }));
         const reject = option(createOptionArgs({
             id: 'reject',
-            title: localize(1224, "Reject"),
+            title: localize(1226, "Reject"),
             icon: Codicon.close,
             commandId: hideInlineCompletionId
         }));
@@ -105,25 +105,25 @@ let GutterIndicatorMenuContent = class GutterIndicatorMenuContent {
         const toggleCollapsedMode = this._inlineEditsShowCollapsed.map(showCollapsed => showCollapsed ?
             option(createOptionArgs({
                 id: 'showExpanded',
-                title: localize(1225, "Show Expanded"),
+                title: localize(1227, "Show Expanded"),
                 icon: Codicon.expandAll,
                 commandId: toggleShowCollapsedId
             }))
             : option(createOptionArgs({
                 id: 'showCollapsed',
-                title: localize(1226, "Show Collapsed"),
+                title: localize(1228, "Show Collapsed"),
                 icon: Codicon.collapseAll,
                 commandId: toggleShowCollapsedId
             })));
         const snooze = option(createOptionArgs({
             id: 'snooze',
-            title: localize(1227, "Snooze"),
+            title: localize(1229, "Snooze"),
             icon: Codicon.bellSlash,
             commandId: 'editor.action.inlineSuggest.snooze'
         }));
         const settings = option(createOptionArgs({
             id: 'settings',
-            title: localize(1228, "Settings"),
+            title: localize(1230, "Settings"),
             icon: Codicon.gear,
             commandId: 'workbench.action.openSettings',
             commandArgs: ['@tag:nextEditSuggestions']

package/esm/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/components/gutterIndicatorView.js

@@ -52,7 +52,7 @@ class InlineEditsGutterIndicatorData {
 class InlineSuggestionGutterMenuData {
     static fromInlineSuggestion(suggestion) {
         const alternativeAction = suggestion.action?.kind === 'edit' ? suggestion.action.alternativeAction : undefined;
-        return new InlineSuggestionGutterMenuData(suggestion.gutterMenuLinkAction, suggestion.source.provider.displayName ?? localize(1229, "Inline Suggestion"), suggestion.source.inlineSuggestions.commands ?? [], alternativeAction, suggestion.source.provider.modelInfo, suggestion.source.provider.setModelId?.bind(suggestion.source.provider));
+        return new InlineSuggestionGutterMenuData(suggestion.gutterMenuLinkAction, suggestion.source.provider.displayName ?? localize(1231, "Inline Suggestion"), suggestion.source.inlineSuggestions.commands ?? [], alternativeAction, suggestion.source.provider.modelInfo, suggestion.source.provider.setModelId?.bind(suggestion.source.provider));
     }
     constructor(action, displayName, extensionCommands, alternativeAction, modelInfo, setModelId) {
         this.action = action;

package/esm/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/inlineEditsViews/inlineEditsWordReplacementView.js

@@ -123,10 +123,10 @@ let InlineEditsWordReplacementView = class InlineEditsWordReplacementView extend
                 const count = altCount.read(reader);
                 const active = altModifierActive.read(reader);
                 const occurrencesLabel = count !== undefined ? count === 1 ?
-                    localize(1230, "{0} 1 occurrence", label) :
-                    localize(1231, "{0} {1} occurrences", label, count)
+                    localize(1232, "{0} 1 occurrence", label) :
+                    localize(1233, "{0} {1} occurrences", label, count)
                     : label;
-                const keybindingTooltip = localize(1232, "{0} show occurrences", '[shift]');
+                const keybindingTooltip = localize(1234, "{0} show occurrences", '[shift]');
                 alternativeAction = {
                     label: count !== undefined ? (active ? occurrencesLabel : label) : label,
                     tooltip: occurrencesLabel ? `${occurrencesLabel}\n${keybindingTooltip}` : undefined,

package/esm/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/theme.js

@@ -21,63 +21,63 @@ import { observableFromEventOpts } from '../../../../../../base/common/observabl
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-const originalBackgroundColor = registerColor('inlineEdit.originalBackground', transparent(diffRemoved, 0.2), localize(1233, 'Background color for the original text in inline edits.'), true);
-const modifiedBackgroundColor = registerColor('inlineEdit.modifiedBackground', transparent(diffInserted, 0.3), localize(1234, 'Background color for the modified text in inline edits.'), true);
-registerColor('inlineEdit.originalChangedLineBackground', transparent(diffRemoved, 0.8), localize(1235, 'Background color for the changed lines in the original text of inline edits.'), true);
-const originalChangedTextOverlayColor = registerColor('inlineEdit.originalChangedTextBackground', transparent(diffRemoved, 0.8), localize(1236, 'Overlay color for the changed text in the original text of inline edits.'), true);
+const originalBackgroundColor = registerColor('inlineEdit.originalBackground', transparent(diffRemoved, 0.2), localize(1235, 'Background color for the original text in inline edits.'), true);
+const modifiedBackgroundColor = registerColor('inlineEdit.modifiedBackground', transparent(diffInserted, 0.3), localize(1236, 'Background color for the modified text in inline edits.'), true);
+registerColor('inlineEdit.originalChangedLineBackground', transparent(diffRemoved, 0.8), localize(1237, 'Background color for the changed lines in the original text of inline edits.'), true);
+const originalChangedTextOverlayColor = registerColor('inlineEdit.originalChangedTextBackground', transparent(diffRemoved, 0.8), localize(1238, 'Overlay color for the changed text in the original text of inline edits.'), true);
 const modifiedChangedLineBackgroundColor = registerColor('inlineEdit.modifiedChangedLineBackground', {
     light: transparent(diffInsertedLine, 0.7),
     dark: transparent(diffInsertedLine, 0.7),
     hcDark: diffInsertedLine,
     hcLight: diffInsertedLine
-}, localize(1237, 'Background color for the changed lines in the modified text of inline edits.'), true);
-const modifiedChangedTextOverlayColor = registerColor('inlineEdit.modifiedChangedTextBackground', transparent(diffInserted, 0.7), localize(1238, 'Overlay color for the changed text in the modified text of inline edits.'), true);
+}, localize(1239, 'Background color for the changed lines in the modified text of inline edits.'), true);
+const modifiedChangedTextOverlayColor = registerColor('inlineEdit.modifiedChangedTextBackground', transparent(diffInserted, 0.7), localize(1240, 'Overlay color for the changed text in the modified text of inline edits.'), true);
 // ------- GUTTER INDICATOR -------
-const inlineEditIndicatorPrimaryForeground = registerColor('inlineEdit.gutterIndicator.primaryForeground', buttonForeground, localize(1239, 'Foreground color for the primary inline edit gutter indicator.'));
-const inlineEditIndicatorPrimaryBorder = registerColor('inlineEdit.gutterIndicator.primaryBorder', buttonBackground, localize(1240, 'Border color for the primary inline edit gutter indicator.'));
+const inlineEditIndicatorPrimaryForeground = registerColor('inlineEdit.gutterIndicator.primaryForeground', buttonForeground, localize(1241, 'Foreground color for the primary inline edit gutter indicator.'));
+const inlineEditIndicatorPrimaryBorder = registerColor('inlineEdit.gutterIndicator.primaryBorder', buttonBackground, localize(1242, 'Border color for the primary inline edit gutter indicator.'));
 const inlineEditIndicatorPrimaryBackground = registerColor('inlineEdit.gutterIndicator.primaryBackground', {
     light: transparent(inlineEditIndicatorPrimaryBorder, 0.5),
     dark: transparent(inlineEditIndicatorPrimaryBorder, 0.4),
     hcDark: transparent(inlineEditIndicatorPrimaryBorder, 0.4),
     hcLight: transparent(inlineEditIndicatorPrimaryBorder, 0.5),
-}, localize(1241, 'Background color for the primary inline edit gutter indicator.'));
-const inlineEditIndicatorSecondaryForeground = registerColor('inlineEdit.gutterIndicator.secondaryForeground', buttonSecondaryForeground, localize(1242, 'Foreground color for the secondary inline edit gutter indicator.'));
-const inlineEditIndicatorSecondaryBorder = registerColor('inlineEdit.gutterIndicator.secondaryBorder', buttonSecondaryBackground, localize(1243, 'Border color for the secondary inline edit gutter indicator.'));
-const inlineEditIndicatorSecondaryBackground = registerColor('inlineEdit.gutterIndicator.secondaryBackground', inlineEditIndicatorSecondaryBorder, localize(1244, 'Background color for the secondary inline edit gutter indicator.'));
-const inlineEditIndicatorSuccessfulForeground = registerColor('inlineEdit.gutterIndicator.successfulForeground', buttonForeground, localize(1245, 'Foreground color for the successful inline edit gutter indicator.'));
-const inlineEditIndicatorSuccessfulBorder = registerColor('inlineEdit.gutterIndicator.successfulBorder', buttonBackground, localize(1246, 'Border color for the successful inline edit gutter indicator.'));
-const inlineEditIndicatorSuccessfulBackground = registerColor('inlineEdit.gutterIndicator.successfulBackground', inlineEditIndicatorSuccessfulBorder, localize(1247, 'Background color for the successful inline edit gutter indicator.'));
+}, localize(1243, 'Background color for the primary inline edit gutter indicator.'));
+const inlineEditIndicatorSecondaryForeground = registerColor('inlineEdit.gutterIndicator.secondaryForeground', buttonSecondaryForeground, localize(1244, 'Foreground color for the secondary inline edit gutter indicator.'));
+const inlineEditIndicatorSecondaryBorder = registerColor('inlineEdit.gutterIndicator.secondaryBorder', buttonSecondaryBackground, localize(1245, 'Border color for the secondary inline edit gutter indicator.'));
+const inlineEditIndicatorSecondaryBackground = registerColor('inlineEdit.gutterIndicator.secondaryBackground', inlineEditIndicatorSecondaryBorder, localize(1246, 'Background color for the secondary inline edit gutter indicator.'));
+const inlineEditIndicatorSuccessfulForeground = registerColor('inlineEdit.gutterIndicator.successfulForeground', buttonForeground, localize(1247, 'Foreground color for the successful inline edit gutter indicator.'));
+const inlineEditIndicatorSuccessfulBorder = registerColor('inlineEdit.gutterIndicator.successfulBorder', buttonBackground, localize(1248, 'Border color for the successful inline edit gutter indicator.'));
+const inlineEditIndicatorSuccessfulBackground = registerColor('inlineEdit.gutterIndicator.successfulBackground', inlineEditIndicatorSuccessfulBorder, localize(1249, 'Background color for the successful inline edit gutter indicator.'));
 const inlineEditIndicatorBackground = registerColor('inlineEdit.gutterIndicator.background', {
     hcDark: transparent('tab.inactiveBackground', 0.5),
     hcLight: transparent('tab.inactiveBackground', 0.5),
     dark: transparent('tab.inactiveBackground', 0.5),
     light: '#5f5f5f18',
-}, localize(1248, 'Background color for the inline edit gutter indicator.'));
+}, localize(1250, 'Background color for the inline edit gutter indicator.'));
 // ------- BORDER COLORS -------
 const originalBorder = registerColor('inlineEdit.originalBorder', {
     light: diffRemoved,
     dark: diffRemoved,
     hcDark: diffRemoved,
     hcLight: diffRemoved
-}, localize(1249, 'Border color for the original text in inline edits.'));
+}, localize(1251, 'Border color for the original text in inline edits.'));
 const modifiedBorder = registerColor('inlineEdit.modifiedBorder', {
     light: darken(diffInserted, 0.6),
     dark: diffInserted,
     hcDark: diffInserted,
     hcLight: diffInserted
-}, localize(1250, 'Border color for the modified text in inline edits.'));
+}, localize(1252, 'Border color for the modified text in inline edits.'));
 const tabWillAcceptModifiedBorder = registerColor('inlineEdit.tabWillAcceptModifiedBorder', {
     light: darken(modifiedBorder, 0),
     dark: darken(modifiedBorder, 0),
     hcDark: darken(modifiedBorder, 0),
     hcLight: darken(modifiedBorder, 0)
-}, localize(1251, 'Modified border color for the inline edits widget when tab will accept it.'));
+}, localize(1253, 'Modified border color for the inline edits widget when tab will accept it.'));
 const tabWillAcceptOriginalBorder = registerColor('inlineEdit.tabWillAcceptOriginalBorder', {
     light: darken(originalBorder, 0),
     dark: darken(originalBorder, 0),
     hcDark: darken(originalBorder, 0),
     hcLight: darken(originalBorder, 0)
-}, localize(1252, 'Original border color for the inline edits widget over the original text when tab will accept it.'));
+}, localize(1254, 'Original border color for the inline edits widget over the original text when tab will accept it.'));
 function getModifiedBorderColor(tabAction) {
     return tabAction.map(a => a === InlineEditTabAction.Accept ? tabWillAcceptModifiedBorder : modifiedBorder);
 }

package/esm/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/utils/utils.js

@@ -22,16 +22,13 @@ import { observableValue } from '../../../../../../../base/common/observableInte
  * Warning: might return 0.
 */
 function maxContentWidthInRange(editor, range, reader) {
-    editor.layoutInfo.read(reader);
-    editor.value.read(reader);
     const model = editor.model.read(reader);
     if (!model) {
         return 0;
     }
     let maxContentWidth = 0;
-    editor.scrollTop.read(reader);
     for (let i = range.startLineNumber; i < range.endLineNumberExclusive; i++) {
-        const lineContentWidth = editor.editor.getWidthOfLine(i);
+        const lineContentWidth = editor.getWidthOfLine(i, reader);
         maxContentWidth = Math.max(maxContentWidth, lineContentWidth);
     }
     const lines = range.mapToLineArray(l => model.getLineContent(l));
@@ -41,17 +38,14 @@ function maxContentWidthInRange(editor, range, reader) {
     return maxContentWidth;
 }
 function getContentSizeOfLines(editor, range, reader) {
-    editor.layoutInfo.read(reader);
-    editor.value.read(reader);
     observableSignalFromEvent(editor, editor.editor.onDidChangeLineHeight).read(reader);
     const model = editor.model.read(reader);
     if (!model) {
         throw new BugIndicatingError('Model is required');
     }
     const sizes = [];
-    editor.scrollTop.read(reader);
     for (let i = range.startLineNumber; i < range.endLineNumberExclusive; i++) {
-        let lineContentWidth = editor.editor.getWidthOfLine(i);
+        let lineContentWidth = editor.getWidthOfLine(i, reader);
         if (lineContentWidth === -1) {
             // approximation
             const column = model.getLineMaxColumn(i);

package/esm/vs/editor/contrib/insertFinalNewLine/browser/insertFinalNewLine.js

@@ -12,7 +12,7 @@ class InsertFinalNewLineAction extends EditorAction {
     constructor() {
         super({
             id: InsertFinalNewLineAction.ID,
-            label: localize2(1255, "Insert Final New Line"),
+            label: localize2(1257, "Insert Final New Line"),
             precondition: EditorContextKeys.writable
         });
     }

package/esm/vs/editor/contrib/lineSelection/browser/lineSelection.js

@@ -11,7 +11,7 @@ class ExpandLineSelectionAction extends EditorAction {
     constructor() {
         super({
             id: 'expandLineSelection',
-            label: localize2(1256, "Expand Line Selection"),
+            label: localize2(1258, "Expand Line Selection"),
             precondition: undefined,
             kbOpts: {
                 weight: 0 /* KeybindingWeight.EditorCore */,