@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/editor/common/model.d.ts

@@ -24,7 +24,8 @@ declare enum OverviewRulerLane {
  */
 declare enum GlyphMarginLane {
     Left = 1,
-    Right = 2
+    Center = 2,
+    Right = 3
 }
 /**
  * Position in the minimap to render the decoration.
@@ -50,6 +51,11 @@ interface IModelDecorationGlyphMarginOptions {
      * The position in the glyph margin.
      */
     position: GlyphMarginLane;
+    /**
+     * Whether the glyph margin lane in {@link position} should be rendered even
+     * outside of this decoration's range.
+     */
+    persistLane?: boolean;
 }
 /**
  * Options for rendering a model decoration in the overview ruler.
@@ -107,6 +113,10 @@ interface IModelDecorationOptions {
      * Array of MarkdownString to render as the decoration message.
      */
     hoverMessage?: IMarkdownString | IMarkdownString[] | null;
+    /**
+     * Array of MarkdownString to render as the line number message.
+     */
+    lineNumberHoverMessage?: IMarkdownString | IMarkdownString[] | null;
     /**
      * Should the decoration expand to encompass a whole line.
      */
@@ -147,6 +157,14 @@ interface IModelDecorationOptions {
      * If set, the decoration will be rendered in the lines decorations with this CSS class name.
      */
     linesDecorationsClassName?: string | null;
+    /**
+     * Controls the tooltip text of the line decoration.
+     */
+    linesDecorationsTooltip?: string | null;
+    /**
+     * If set, the decoration will be rendered on the line number.
+     */
+    lineNumberClassName?: string | null;
     /**
      * If set, the decoration will be rendered in the lines decorations with this CSS class name, but only for the first line in case of line wrapping.
      */

package/vscode/src/vs/editor/common/model.js

@@ -9,7 +9,8 @@ var OverviewRulerLane;
 var GlyphMarginLane;
 ( (function(GlyphMarginLane) {
     GlyphMarginLane[GlyphMarginLane["Left"] = 1] = "Left";
-    GlyphMarginLane[GlyphMarginLane["Right"] = 2] = "Right";
+    GlyphMarginLane[GlyphMarginLane["Center"] = 2] = "Center";
+    GlyphMarginLane[GlyphMarginLane["Right"] = 3] = "Right";
 })(GlyphMarginLane || (GlyphMarginLane = {})));
 var MinimapPosition;
 ( (function(MinimapPosition) {

package/vscode/src/vs/editor/common/services/editorSimpleWorker.js

@@ -260,7 +260,8 @@ class EditorSimpleWorker {
         if (!original || !modified) {
             return null;
         }
-        return EditorSimpleWorker.computeDiff(original, modified, options, algorithm);
+        const result = EditorSimpleWorker.computeDiff(original, modified, options, algorithm);
+        return result;
     }
     static computeDiff(originalTextModel, modifiedTextModel, options, algorithm) {
         const diffAlgorithm = algorithm === 'advanced' ? linesDiffComputers.getDefault() : linesDiffComputers.getLegacy();

package/vscode/src/vs/editor/common/services/getIconClasses.js

@@ -3,7 +3,10 @@ import { DataUri } from '../../../base/common/resources.js';
 import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
 import { FileKind } from '../../../platform/files/common/files.js';
 const fileIconDirectoryRegex = /(?:\/|^)(?:([^\/]+)\/)?([^\/]+)$/;
-function getIconClasses(modelService, languageService, resource, fileKind) {
+function getIconClasses(modelService, languageService, resource, fileKind, icon) {
+    if (icon) {
+        return [`codicon-${icon.id}`, 'predefined-file-icon'];
+    }
     const classes = fileKind === FileKind.ROOT_FOLDER ? ['rootfolder-icon'] : fileKind === FileKind.FOLDER ? ['folder-icon'] : ['file-icon'];
     if (resource) {
         let name;

package/vscode/src/vs/editor/common/services/semanticTokensProviderStyling.js

@@ -88,19 +88,19 @@ let SemanticTokensProviderStyling = class SemanticTokensProviderStyling {
     warnOverlappingSemanticTokens(lineNumber, startColumn) {
         if (!this._hasWarnedOverlappingTokens) {
             this._hasWarnedOverlappingTokens = true;
-            console.warn(`Overlapping semantic tokens detected at lineNumber ${lineNumber}, column ${startColumn}`);
+            this._logService.warn(`Overlapping semantic tokens detected at lineNumber ${lineNumber}, column ${startColumn}`);
         }
     }
     warnInvalidLengthSemanticTokens(lineNumber, startColumn) {
         if (!this._hasWarnedInvalidLengthTokens) {
             this._hasWarnedInvalidLengthTokens = true;
-            console.warn(`Semantic token with invalid length detected at lineNumber ${lineNumber}, column ${startColumn}`);
+            this._logService.warn(`Semantic token with invalid length detected at lineNumber ${lineNumber}, column ${startColumn}`);
         }
     }
     warnInvalidEditStart(previousResultId, resultId, editIndex, editStart, maxExpectedStart) {
         if (!this._hasWarnedInvalidEditStart) {
             this._hasWarnedInvalidEditStart = true;
-            console.warn(`Invalid semantic tokens edit detected (previousResultId: ${previousResultId}, resultId: ${resultId}) at edit #${editIndex}: The provided start offset ${editStart} is outside the previous data (length ${maxExpectedStart}).`);
+            this._logService.warn(`Invalid semantic tokens edit detected (previousResultId: ${previousResultId}, resultId: ${resultId}) at edit #${editIndex}: The provided start offset ${editStart} is outside the previous data (length ${maxExpectedStart}).`);
         }
     }
 };

package/vscode/src/vs/editor/common/standalone/standaloneEnums.js

@@ -256,7 +256,8 @@ var EndOfLineSequence;
 var GlyphMarginLane;
 ( (function(GlyphMarginLane) {
     GlyphMarginLane[GlyphMarginLane["Left"] = 1] = "Left";
-    GlyphMarginLane[GlyphMarginLane["Right"] = 2] = "Right";
+    GlyphMarginLane[GlyphMarginLane["Center"] = 2] = "Center";
+    GlyphMarginLane[GlyphMarginLane["Right"] = 3] = "Right";
 })(GlyphMarginLane || (GlyphMarginLane = {})));
 var IndentAction;
 ( (function(IndentAction) {
@@ -504,12 +505,12 @@ var SelectionDirection;
     SelectionDirection[SelectionDirection["LTR"] = 0] = "LTR";
     SelectionDirection[SelectionDirection["RTL"] = 1] = "RTL";
 })(SelectionDirection || (SelectionDirection = {})));
-var ShowAiIconMode;
-( (function(ShowAiIconMode) {
-    ShowAiIconMode["Off"] = "off";
-    ShowAiIconMode["OnCode"] = "onCode";
-    ShowAiIconMode["On"] = "on";
-})(ShowAiIconMode || (ShowAiIconMode = {})));
+var ShowLightbulbIconMode;
+( (function(ShowLightbulbIconMode) {
+    ShowLightbulbIconMode["Off"] = "off";
+    ShowLightbulbIconMode["OnCode"] = "onCode";
+    ShowLightbulbIconMode["On"] = "on";
+})(ShowLightbulbIconMode || (ShowLightbulbIconMode = {})));
 var SignatureHelpTriggerKind;
 ( (function(SignatureHelpTriggerKind) {
     SignatureHelpTriggerKind[SignatureHelpTriggerKind["Invoke"] = 1] = "Invoke";
@@ -581,4 +582,4 @@ var WrappingIndent;
     WrappingIndent[WrappingIndent["Indent"] = 2] = "Indent";
     WrappingIndent[WrappingIndent["DeepIndent"] = 3] = "DeepIndent";
 })(WrappingIndent || (WrappingIndent = {})));
-export { AccessibilitySupport, CodeActionTriggerType, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemTag, CompletionTriggerKind, ContentWidgetPositionPreference, CursorChangeReason, DefaultEndOfLine, DocumentHighlightKind, EditorAutoIndentStrategy, EditorOption, EndOfLinePreference, EndOfLineSequence, GlyphMarginLane, IndentAction, InjectedTextCursorStops, InlayHintKind, InlineCompletionTriggerKind, KeyCode, MarkerSeverity, MarkerTag, MinimapPosition, MouseTargetType, OverlayWidgetPositionPreference, OverviewRulerLane, PositionAffinity, RenderLineNumbersType, RenderMinimap, ScrollType, ScrollbarVisibility, SelectionDirection, ShowAiIconMode, SignatureHelpTriggerKind, SymbolKind, SymbolTag, TextEditorCursorBlinkingStyle, TextEditorCursorStyle, TrackedRangeStickiness, WrappingIndent };
+export { AccessibilitySupport, CodeActionTriggerType, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemTag, CompletionTriggerKind, ContentWidgetPositionPreference, CursorChangeReason, DefaultEndOfLine, DocumentHighlightKind, EditorAutoIndentStrategy, EditorOption, EndOfLinePreference, EndOfLineSequence, GlyphMarginLane, IndentAction, InjectedTextCursorStops, InlayHintKind, InlineCompletionTriggerKind, KeyCode, MarkerSeverity, MarkerTag, MinimapPosition, MouseTargetType, OverlayWidgetPositionPreference, OverviewRulerLane, PositionAffinity, RenderLineNumbersType, RenderMinimap, ScrollType, ScrollbarVisibility, SelectionDirection, ShowLightbulbIconMode, SignatureHelpTriggerKind, SymbolKind, SymbolTag, TextEditorCursorBlinkingStyle, TextEditorCursorStyle, TrackedRangeStickiness, WrappingIndent };

package/vscode/src/vs/editor/common/standaloneStrings.js

@@ -96,35 +96,35 @@ var AccessibilityHelpNLS;
         "showAccessibilityHelpAction",
         "Show Accessibility Help"
     ));
-    AccessibilityHelpNLS.saveAudioCueDisabled = ( localizeWithPath(
+    AccessibilityHelpNLS.listAudioCues = ( localizeWithPath(
         'vs/editor/common/standaloneStrings',
-        "saveAudioCueDisabled",
-        "`audioCues.save` is disabled, so an alert will occur when a file is saved."
+        "listAudioCuesCommand",
+        "Run the command: List Audio Cues for an overview of all audio cues and their current status."
     ));
-    AccessibilityHelpNLS.saveAudioCueAlways = ( localizeWithPath(
+    AccessibilityHelpNLS.listAlerts = ( localizeWithPath(
         'vs/editor/common/standaloneStrings',
-        "saveAudioCueAlways",
-        "`audioCues.save` is enabled, so will play whenever a file is saved."
+        "listAlertsCommand",
+        "Run the command: List Alerts for an overview of alerts and their current status."
     ));
-    AccessibilityHelpNLS.saveAudioCueUserGesture = ( localizeWithPath(
+    AccessibilityHelpNLS.quickChat = ( localizeWithPath(
         'vs/editor/common/standaloneStrings',
-        "saveAudioCueUserGesture",
-        "`audioCues.save` is enabled, so will play when a file is saved via user gesture."
+        "quickChatCommand",
+        "Toggle quick chat ({0}) to open or close a chat session."
     ));
-    AccessibilityHelpNLS.formatAudioCueDisabled = ( localizeWithPath(
+    AccessibilityHelpNLS.quickChatNoKb = ( localizeWithPath(
         'vs/editor/common/standaloneStrings',
-        "formatAudioCueDisabled",
-        "`audioCues.format` is disabled, so an alert will occur when a file is formatted."
+        "quickChatCommandNoKb",
+        "Toggle quick chat is not currently triggerable by a keybinding."
     ));
-    AccessibilityHelpNLS.formatAudioCueAlways = ( localizeWithPath(
+    AccessibilityHelpNLS.startInlineChat = ( localizeWithPath(
         'vs/editor/common/standaloneStrings',
-        "formatAudioCueAlways",
-        "`audioCues.format` is enabled, so will play whenever a file is formatted."
+        "startInlineChatCommand",
+        "Start inline chat ({0}) to create an in editor chat session."
     ));
-    AccessibilityHelpNLS.formatAudioCueUserGesture = ( localizeWithPath(
+    AccessibilityHelpNLS.startInlineChatNoKb = ( localizeWithPath(
         'vs/editor/common/standaloneStrings',
-        "formatAudioCueUserGesture",
-        "`audioCues.format` is enabled, so will play when a file is formatted via user gesture."
+        "startInlineChatCommandNoKb",
+        "The command: Start inline chat is not currentlyt riggerable by a keybinding."
     ));
 })(AccessibilityHelpNLS || (AccessibilityHelpNLS = {})));
 var StandaloneCodeEditorNLS;

package/vscode/src/vs/editor/common/viewEvents.js

@@ -32,11 +32,13 @@ class ViewDecorationsChangedEvent {
             this.affectsMinimap = source.affectsMinimap;
             this.affectsOverviewRuler = source.affectsOverviewRuler;
             this.affectsGlyphMargin = source.affectsGlyphMargin;
+            this.affectsLineNumber = source.affectsLineNumber;
         }
         else {
             this.affectsMinimap = true;
             this.affectsOverviewRuler = true;
             this.affectsGlyphMargin = true;
+            this.affectsLineNumber = true;
         }
     }
 }

package/vscode/src/vs/editor/common/viewModel/glyphLanesModel.js

@@ -0,0 +1,55 @@
+import { GlyphMarginLane } from '../model.js';
+const MAX_LANE = GlyphMarginLane.Right;
+class GlyphMarginLanesModel {
+    constructor(maxLine) {
+        this.persist = 0;
+        this._requiredLanes = 1;
+        this.lanes = ( new Uint8Array(Math.ceil(((maxLine + 1) * MAX_LANE) / 8)));
+    }
+    reset(maxLine) {
+        const bytes = Math.ceil(((maxLine + 1) * MAX_LANE) / 8);
+        if (this.lanes.length < bytes) {
+            this.lanes = ( new Uint8Array(bytes));
+        }
+        else {
+            this.lanes.fill(0);
+        }
+        this._requiredLanes = 1;
+    }
+    get requiredLanes() {
+        return this._requiredLanes;
+    }
+    push(lane, range, persist) {
+        if (persist) {
+            this.persist |= (1 << (lane - 1));
+        }
+        for (let i = range.startLineNumber; i <= range.endLineNumber; i++) {
+            const bit = (MAX_LANE * i) + (lane - 1);
+            this.lanes[bit >>> 3] |= (1 << (bit % 8));
+            this._requiredLanes = Math.max(this._requiredLanes, this.countAtLine(i));
+        }
+    }
+    getLanesAtLine(lineNumber) {
+        const lanes = [];
+        let bit = MAX_LANE * lineNumber;
+        for (let i = 0; i < MAX_LANE; i++) {
+            if (this.persist & (1 << i) || this.lanes[bit >>> 3] & (1 << (bit % 8))) {
+                lanes.push(i + 1);
+            }
+            bit++;
+        }
+        return lanes.length ? lanes : [GlyphMarginLane.Center];
+    }
+    countAtLine(lineNumber) {
+        let bit = MAX_LANE * lineNumber;
+        let count = 0;
+        for (let i = 0; i < MAX_LANE; i++) {
+            if (this.persist & (1 << i) || this.lanes[bit >>> 3] & (1 << (bit % 8))) {
+                count++;
+            }
+            bit++;
+        }
+        return count;
+    }
+}
+export { GlyphMarginLanesModel };

package/vscode/src/vs/editor/common/viewModel/viewModelImpl.js

@@ -20,6 +20,7 @@ import { ViewLineRenderingData, MinimapLinesRenderingData, OverviewRulerDecorati
 import { ViewModelDecorations } from './viewModelDecorations.js';
 import { ViewModelEventDispatcher, ScrollChangedEvent, FocusChangedEvent, ModelContentChangedEvent, ModelTokensChangedEvent, ModelLanguageConfigurationChangedEvent, ModelLanguageChangedEvent, ModelOptionsChangedEvent, ModelDecorationsChangedEvent, HiddenAreasChangedEvent, ReadOnlyEditAttemptEvent, ViewZonesChangedEvent as ViewZonesChangedEvent$1 } from '../viewModelEventDispatcher.js';
 import { ViewModelLinesFromModelAsIs, ViewModelLinesFromProjectedModel } from './viewModelLines.js';
+import { GlyphMarginLanesModel } from './glyphLanesModel.js';
 class ViewModel extends Disposable {
     constructor(editorId, configuration, model, domLineBreaksComputerFactory, monospaceLineBreaksComputerFactory, scheduleAtNextAnimationFrame, languageConfigurationService, _themeService, _attachedView) {
         super();
@@ -42,6 +43,7 @@ class ViewModel extends Disposable {
         this._updateConfigurationViewLineCount = this._register(( new RunOnceScheduler(() => this._updateConfigurationViewLineCountNow(), 0)));
         this._hasFocus = false;
         this._viewportStart = ViewportStart.create(this.model);
+        this.glyphLanes = ( new GlyphMarginLanesModel(0));
         if (this.model.isTooLargeForTokenization()) {
             this._lines = ( new ViewModelLinesFromModelAsIs(this.model));
         }
@@ -683,7 +685,8 @@ class ViewModel extends Disposable {
     }
     modifyPosition(position, offset) {
         const modelPosition = this.coordinatesConverter.convertViewPositionToModelPosition(position);
-        return this.model.modifyPosition(modelPosition, offset);
+        const resultModelPosition = this.model.modifyPosition(modelPosition, offset);
+        return this.coordinatesConverter.convertModelPositionToViewPosition(resultModelPosition);
     }
     deduceModelPositionRelativeToViewPosition(viewAnchorPosition, deltaOffset, lineFeedCnt) {
         const modelAnchor = this.coordinatesConverter.convertViewPositionToModelPosition(viewAnchorPosition);

package/vscode/src/vs/editor/contrib/clipboard/browser/clipboard.js

@@ -5,6 +5,7 @@ import { InMemoryClipboardMetadataManager, CopyOptions } from '../../../browser/
 import { registerEditorAction, MultiCommand, EditorAction } from '../../../browser/editorExtensions.js';
 import { ICodeEditorService } from '../../../browser/services/codeEditorService.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { CopyPasteController } from '../../dropOrPasteInto/browser/copyPasteController.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { MenuRegistry, MenuId } from '../../../../platform/actions/common/actions.js';
 import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
@@ -231,7 +232,10 @@ if (PasteAction) {
         const focusedEditor = codeEditorService.getFocusedCodeEditor();
         if (focusedEditor && focusedEditor.hasTextFocus()) {
             const result = focusedEditor.getContainerDomNode().ownerDocument.execCommand('paste');
-            if (!result && isWeb) {
+            if (result) {
+                return CopyPasteController.get(focusedEditor)?.finishedPaste() ?? Promise.resolve();
+            }
+            else if (isWeb) {
                 return (async () => {
                     const clipboardText = await clipboardService.readText();
                     if (clipboardText !== '') {

package/vscode/src/vs/editor/contrib/codeAction/browser/codeAction.js

@@ -188,6 +188,7 @@ var ApplyCodeActionReason;
     ApplyCodeActionReason["OnSave"] = "onSave";
     ApplyCodeActionReason["FromProblemsView"] = "fromProblemsView";
     ApplyCodeActionReason["FromCodeActions"] = "fromCodeActions";
+    ApplyCodeActionReason["FromAILightbulb"] = "fromAILightbulb";
 })(ApplyCodeActionReason || (ApplyCodeActionReason = {})));
 async function applyCodeAction(accessor, item, codeActionReason, options, token = CancellationToken.None) {
     const bulkEditService = accessor.get(IBulkEditService);

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionController.js

@@ -7,7 +7,7 @@ import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle
 import { Position } from '../../../common/core/position.js';
 import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
-import { applyCodeAction, ApplyCodeActionReason } from './codeAction.js';
+import { ApplyCodeActionReason, applyCodeAction } from './codeAction.js';
 import { CodeActionKeybindingResolver } from './codeActionKeybindingResolver.js';
 import { toMenuItems } from './codeActionMenu.js';
 import { LightBulbWidget } from './lightBulbWidget.js';
@@ -55,7 +55,7 @@ let CodeActionController = class CodeActionController extends Disposable {
         this._lightBulbWidget = ( new Lazy(() => {
             const widget = this._editor.getContribution(LightBulbWidget.ID);
             if (widget) {
-                this._register(widget.onClick(e => this.showCodeActionList(e.actions, e, { includeDisabledActions: false, fromLightbulb: true })));
+                this._register(widget.onClick(e => this.showCodeActionsFromLightbulb(e.actions, e)));
             }
             return widget;
         }));
@@ -66,6 +66,20 @@ let CodeActionController = class CodeActionController extends Disposable {
         this._disposed = true;
         super.dispose();
     }
+    async showCodeActionsFromLightbulb(actions, at) {
+        if (actions.allAIFixes && actions.validActions.length === 1) {
+            const actionItem = actions.validActions[0];
+            const command = actionItem.action.command;
+            if (command && command.id === 'inlineChat.start') {
+                if (command.arguments && command.arguments.length >= 1) {
+                    command.arguments[0] = { ...command.arguments[0], autoSend: false };
+                }
+            }
+            await this._applyCodeAction(actionItem, false, false, ApplyCodeActionReason.FromAILightbulb);
+            return;
+        }
+        await this.showCodeActionList(actions, at, { includeDisabledActions: false, fromLightbulb: true });
+    }
     showCodeActions(_trigger, actions, at) {
         return this.showCodeActionList(actions, at, { includeDisabledActions: false, fromLightbulb: false });
     }
@@ -83,9 +97,9 @@ let CodeActionController = class CodeActionController extends Disposable {
     _trigger(trigger) {
         return this._model.trigger(trigger);
     }
-    async _applyCodeAction(action, retrigger, preview) {
+    async _applyCodeAction(action, retrigger, preview, actionReason) {
         try {
-            await this._instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.FromCodeActions, { preview, editor: this._editor });
+            await this._instantiationService.invokeFunction(applyCodeAction, action, actionReason, { preview, editor: this._editor });
         }
         finally {
             if (retrigger) {
@@ -119,7 +133,7 @@ let CodeActionController = class CodeActionController extends Disposable {
                 if (validActionToApply) {
                     try {
                         this._lightBulbWidget.value?.hide();
-                        await this._applyCodeAction(validActionToApply, false, false);
+                        await this._applyCodeAction(validActionToApply, false, false, ApplyCodeActionReason.FromCodeActions);
                     }
                     finally {
                         actions.dispose();
@@ -193,7 +207,7 @@ let CodeActionController = class CodeActionController extends Disposable {
         const anchor = Position.isIPosition(at) ? this.toCoords(at) : at;
         const delegate = {
             onSelect: async (action, preview) => {
-                this._applyCodeAction(action,  true, !!preview);
+                this._applyCodeAction(action,  true, !!preview, ApplyCodeActionReason.FromCodeActions);
                 this._actionWidgetService.hide();
                 currentDecorations.clear();
             },
@@ -202,26 +216,38 @@ let CodeActionController = class CodeActionController extends Disposable {
                 currentDecorations.clear();
             },
             onHover: async (action, token) => {
-                await action.resolve(token);
                 if (token.isCancellationRequested) {
                     return;
                 }
                 return { canPreview: !!action.action.edit?.edits.length };
             },
             onFocus: (action) => {
-                if (action && action.highlightRange && action.action.diagnostics) {
-                    const decorations = [{ range: action.action.diagnostics[0], options: CodeActionController_1.DECORATION }];
-                    currentDecorations.set(decorations);
-                    const diagnostic = action.action.diagnostics[0];
-                    const selectionText = this._editor.getModel()?.getWordAtPosition({ lineNumber: diagnostic.startLineNumber, column: diagnostic.startColumn })?.word;
-                    status(( localizeWithPath(
-                        'vs/editor/contrib/codeAction/browser/codeActionController',
-                        'editingNewSelection',
-                        "Context: {0} at line {1} and column {2}.",
-                        selectionText,
-                        diagnostic.startLineNumber,
-                        diagnostic.startColumn
-                    )));
+                if (action && action.action) {
+                    const ranges = action.action.ranges;
+                    const diagnostics = action.action.diagnostics;
+                    currentDecorations.clear();
+                    if (ranges && ranges.length > 0) {
+                        const decorations = ( ranges.map(range => ({ range, options: CodeActionController_1.DECORATION })));
+                        currentDecorations.set(decorations);
+                    }
+                    else if (diagnostics && diagnostics.length > 0) {
+                        const decorations = ( diagnostics.map(
+                            diagnostic => ({ range: diagnostic, options: CodeActionController_1.DECORATION })
+                        ));
+                        currentDecorations.set(decorations);
+                        const diagnostic = diagnostics[0];
+                        if (diagnostic.startLineNumber && diagnostic.startColumn) {
+                            const selectionText = this._editor.getModel()?.getWordAtPosition({ lineNumber: diagnostic.startLineNumber, column: diagnostic.startColumn })?.word;
+                            status(( localizeWithPath(
+                                'vs/editor/contrib/codeAction/browser/codeActionController',
+                                'editingNewSelection',
+                                "Context: {0} at line {1} and column {2}.",
+                                selectionText,
+                                diagnostic.startLineNumber,
+                                diagnostic.startColumn
+                            )));
+                        }
+                    }
                 }
                 else {
                     currentDecorations.clear();

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionMenu.js

@@ -39,7 +39,7 @@ const codeActionGroups = ( Object.freeze([
         'vs/editor/contrib/codeAction/browser/codeActionMenu',
         'codeAction.widget.id.surround',
         'Surround With'
-    )), icon: Codicon.symbolSnippet },
+    )), icon: Codicon.surroundWith },
     { kind: CodeActionKind.Source, title: ( localizeWithPath(
         'vs/editor/contrib/codeAction/browser/codeActionMenu',
         'codeAction.widget.id.source',

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionModel.js

@@ -3,7 +3,7 @@ import { isCancellationError } from '../../../../base/common/errors.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { isEqual } from '../../../../base/common/resources.js';
-import { ShowAiIconMode } from '../../../common/config/editorOptions.js';
+import { ShowLightbulbIconMode } from '../../../common/config/editorOptions.js';
 import { Position } from '../../../common/core/position.js';
 import { Selection } from '../../../common/core/selection.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
@@ -11,6 +11,7 @@ import { Progress } from '../../../../platform/progress/common/progress.js';
 import { CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
 import { getCodeActions } from './codeAction.js';
 const SUPPORTED_CODE_ACTIONS = ( new RawContextKey('supportedCodeAction', ''));
+const APPLY_FIX_ALL_COMMAND_ID = '_typescript.applyFixAllCodeAction';
 class CodeActionOracle extends Disposable {
     constructor(_editor, _markerService, _signalChange, _delay = 250) {
         super();
@@ -41,16 +42,27 @@ class CodeActionOracle extends Disposable {
         if (!this._editor.hasModel()) {
             return undefined;
         }
-        const model = this._editor.getModel();
         const selection = this._editor.getSelection();
-        if (selection.isEmpty() && trigger.type === 2 ) {
+        if (trigger.type === 1 ) {
+            return selection;
+        }
+        const enabled = this._editor.getOption(64 ).enabled;
+        if (enabled === ShowLightbulbIconMode.Off) {
+            return undefined;
+        }
+        else if (enabled === ShowLightbulbIconMode.On) {
+            return selection;
+        }
+        else if (enabled === ShowLightbulbIconMode.OnCode) {
+            const isSelectionEmpty = selection.isEmpty();
+            if (!isSelectionEmpty) {
+                return selection;
+            }
+            const model = this._editor.getModel();
             const { lineNumber, column } = selection.getPosition();
             const line = model.getLineContent(lineNumber);
             if (line.length === 0) {
-                const showAiIconOnEmptyLines = this._editor.getOption(64 ).experimental?.showAiIcon === ShowAiIconMode.On;
-                if (!showAiIconOnEmptyLines) {
-                    return undefined;
-                }
+                return undefined;
             }
             else if (column === 1) {
                 if (/\s/.test(line[0])) {
@@ -123,6 +135,11 @@ class CodeActionModel extends Disposable {
         this._register(this._editor.onDidChangeModel(() => this._update()));
         this._register(this._editor.onDidChangeModelLanguage(() => this._update()));
         this._register(this._registry.onDidChange(() => this._update()));
+        this._register(this._editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(64 )) {
+                this._update();
+            }
+        }));
         this._update();
     }
     dispose() {
@@ -163,8 +180,16 @@ class CodeActionModel extends Disposable {
                             return emptyCodeActionSet;
                         }
                         const foundQuickfix = codeActionSet.validActions?.some(action => action.action.kind ? CodeActionKind.QuickFix.contains(( new CodeActionKind(action.action.kind))) : false);
-                        if (!foundQuickfix) {
-                            const allMarkers = this._markerService.read({ resource: model.uri });
+                        const allMarkers = this._markerService.read({ resource: model.uri });
+                        if (foundQuickfix) {
+                            for (const action of codeActionSet.validActions) {
+                                if (action.action.command?.arguments?.some(arg => typeof arg === 'string' && arg.includes(APPLY_FIX_ALL_COMMAND_ID))) {
+                                    action.action.diagnostics = [...allMarkers.filter(marker => marker.relatedInformation)];
+                                }
+                            }
+                            return { validActions: codeActionSet.validActions, allActions: allCodeActions, documentation: codeActionSet.documentation, hasAutoFix: codeActionSet.hasAutoFix, hasAIFix: codeActionSet.hasAIFix, allAIFixes: codeActionSet.allAIFixes, dispose: () => { codeActionSet.dispose(); } };
+                        }
+                        else if (!foundQuickfix) {
                             if (allMarkers.length > 0) {
                                 const currPosition = trigger.selection.getPosition();
                                 let trackedPosition = currPosition;
@@ -192,7 +217,9 @@ class CodeActionModel extends Disposable {
                                         const actionsAtMarker = await getCodeActions(this._registry, model, selectionAsPosition, newCodeActionTrigger, Progress.None, token);
                                         if (actionsAtMarker.validActions.length !== 0) {
                                             for (const action of actionsAtMarker.validActions) {
-                                                action.highlightRange = action.action.isPreferred;
+                                                if (action.action.command?.arguments?.some(arg => typeof arg === 'string' && arg.includes(APPLY_FIX_ALL_COMMAND_ID))) {
+                                                    action.action.diagnostics = [...allMarkers.filter(marker => marker.relatedInformation)];
+                                                }
                                             }
                                             if (codeActionSet.allActions.length === 0) {
                                                 allCodeActions.push(...actionsAtMarker.allActions);
@@ -258,4 +285,4 @@ class CodeActionModel extends Disposable {
         }
     }
 }
-export { CodeActionModel, CodeActionsState, SUPPORTED_CODE_ACTIONS };
+export { APPLY_FIX_ALL_COMMAND_ID, CodeActionModel, CodeActionsState, SUPPORTED_CODE_ACTIONS };