@codingame/monaco-vscode-api 1.82.6 → 1.83.0-next.0

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkEditService.js

@@ -187,7 +187,7 @@ let BulkEditService = class BulkEditService {
                 codeEditor = candidate.getModifiedEditor();
             }
         }
-        if (codeEditor && codeEditor.getOption(89 )) {
+        if (codeEditor && codeEditor.getOption(90 )) {
             codeEditor = undefined;
         }
         let undoRedoGroup;

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkTextEdits.js

@@ -165,7 +165,7 @@ let BulkTextEdits = class BulkTextEdits {
     async _createEditsTasks() {
         const tasks = [];
         const promises = [];
-        for (const [key, value] of this._edits) {
+        for (const [key, edits] of this._edits) {
             const promise = this._textModelResolverService.createModelReference(key).then(async (ref) => {
                 let task;
                 let makeMinimal = false;
@@ -176,23 +176,31 @@ let BulkTextEdits = class BulkTextEdits {
                 else {
                     task = ( new ModelEditTask(ref));
                 }
-                for (const edit of value) {
-                    if (makeMinimal && !edit.textEdit.insertAsSnippet) {
-                        const newEdits = await this._editorWorker.computeMoreMinimalEdits(edit.resource, [edit.textEdit]);
-                        if (!newEdits) {
-                            task.addEdit(edit);
-                        }
-                        else {
-                            for (const moreMinialEdit of newEdits) {
-                                task.addEdit(( new ResourceTextEdit(edit.resource, moreMinialEdit, edit.versionId, edit.metadata)));
-                            }
-                        }
+                tasks.push(task);
+                if (!makeMinimal) {
+                    edits.forEach(task.addEdit, task);
+                    return;
+                }
+                const makeGroupMoreMinimal = async (start, end) => {
+                    const oldEdits = edits.slice(start, end);
+                    const newEdits = await this._editorWorker.computeMoreMinimalEdits(ref.object.textEditorModel.uri, ( oldEdits.map(e => e.textEdit)), false);
+                    if (!newEdits) {
+                        oldEdits.forEach(task.addEdit, task);
                     }
                     else {
-                        task.addEdit(edit);
+                        newEdits.forEach(edit => task.addEdit(( new ResourceTextEdit(ref.object.textEditorModel.uri, edit, undefined, undefined))));
+                    }
+                };
+                let start = 0;
+                let i = 0;
+                for (; i < edits.length; i++) {
+                    if (edits[i].textEdit.insertAsSnippet || edits[i].metadata) {
+                        await makeGroupMoreMinimal(start, i);
+                        task.addEdit(edits[i]);
+                        start = i + 1;
                     }
                 }
-                tasks.push(task);
+                await makeGroupMoreMinimal(start, i);
             });
             promises.push(promise);
         }

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatActions.js

@@ -0,0 +1,2 @@
+const CHAT_OPEN_ACTION_ID = 'workbench.action.chat.open';
+export { CHAT_OPEN_ACTION_ID };

package/vscode/src/vs/workbench/contrib/chat/common/chatAgents.js

@@ -0,0 +1,136 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Disposable, toDisposable, combinedDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { isProposedApiEnabled } from '../../../services/extensions/common/extensions.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+const agentItem = {
+    type: 'object',
+    required: ['agent', 'detail'],
+    properties: {
+        agent: {
+            type: 'string',
+            markdownDescription: ( localize('agent', "The name of the agent which will be used as prefix."))
+        },
+        detail: {
+            type: 'string',
+            markdownDescription: ( localize('details', "The details of the agent."))
+        },
+    }
+};
+const agentItems = {
+    description: ( localize('vscode.extension.contributes.slashes', "Contributes agents to chat")),
+    oneOf: [
+        agentItem,
+        {
+            type: 'array',
+            items: agentItem
+        }
+    ]
+};
+const agentsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'agents',
+    jsonSchema: agentItems
+}));
+function isAgentData(data) {
+    return typeof data === 'object' && data &&
+        typeof data.id === 'string' &&
+        typeof data.detail === 'string';
+}
+const IChatAgentService = ( createDecorator('chatAgentService'));
+(class ChatAgentService extends Disposable {
+    static { this.AGENT_LEADER = '@'; }
+    constructor(_extensionService) {
+        super();
+        this._extensionService = _extensionService;
+        this._agents = ( new Map());
+        this._onDidChangeAgents = this._register(( new Emitter()));
+        this.onDidChangeAgents = this._onDidChangeAgents.event;
+    }
+    dispose() {
+        super.dispose();
+        this._agents.clear();
+    }
+    registerAgentData(data) {
+        if (( this._agents.has(data.id))) {
+            throw new Error(`Already registered an agent with id ${data.id}}`);
+        }
+        this._agents.set(data.id, { data });
+        this._onDidChangeAgents.fire();
+        return toDisposable(() => {
+            if (this._agents.delete(data.id)) {
+                this._onDidChangeAgents.fire();
+            }
+        });
+    }
+    registerAgentCallback(id, agentCallback) {
+        const data = this._agents.get(id);
+        if (!data) {
+            throw new Error(`No agent with id ${id} registered`);
+        }
+        data.callback = agentCallback;
+        return toDisposable(() => data.callback = undefined);
+    }
+    registerAgent(data, callback) {
+        return combinedDisposable(this.registerAgentData(data), this.registerAgentCallback(data.id, callback));
+    }
+    getAgents() {
+        return Array.from(( this._agents.values()), v => v.data);
+    }
+    hasAgent(id) {
+        return ( this._agents.has(id));
+    }
+    getAgent(id) {
+        const data = this._agents.get(id);
+        return data?.data;
+    }
+    async invokeAgent(id, prompt, progress, history, token) {
+        const data = this._agents.get(id);
+        if (!data) {
+            throw new Error('No agent with id ${id} NOT registered');
+        }
+        if (!data.callback) {
+            await this._extensionService.activateByEvent(`onChatAgent:${id}`);
+        }
+        if (!data.callback) {
+            throw new Error(`No agent with id ${id} NOT resolved`);
+        }
+        return await data.callback(prompt, progress, history, token);
+    }
+});
+let ChatAgentContribution = class ChatAgentContribution {
+    constructor(chatAgentService) {
+        const contributions = ( new DisposableStore());
+        agentsExtPoint.setHandler(extensions => {
+            contributions.clear();
+            for (const entry of extensions) {
+                if (!isProposedApiEnabled(entry.description, 'chatAgents')) {
+                    entry.collector.error(`The ${agentsExtPoint.name} is proposed API`);
+                    continue;
+                }
+                const { value } = entry;
+                for (const candidate of Iterable.wrap(value)) {
+                    if (!isAgentData(candidate)) {
+                        entry.collector.error(( localize(
+                            'invalid',
+                            "Invalid {0}: {1}",
+                            agentsExtPoint.name,
+                            JSON.stringify(candidate)
+                        )));
+                        continue;
+                    }
+                    contributions.add(chatAgentService.registerAgentData({ ...candidate }));
+                }
+            }
+        });
+    }
+};
+ChatAgentContribution = ( __decorate([
+    ( __param(0, IChatAgentService))
+], ChatAgentContribution));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ChatAgentContribution, 3 );
+export { IChatAgentService, agentsExtPoint };

package/vscode/src/vs/workbench/contrib/chat/common/chatModel.js

@@ -29,6 +29,9 @@ class Response {
     get onDidChangeValue() {
         return this._onDidChangeValue.event;
     }
+    get usedContext() {
+        return this._usedContext;
+    }
     get value() {
         return this._responseData;
     }
@@ -71,6 +74,10 @@ class Response {
                     this._responseParts[responsePosition] = { string: ( new MarkdownString(content)), isPlaceholder: true };
                     this._updateRepr(quiet);
                 }
+                else if ('value' in content) {
+                    this._responseParts[responsePosition] = { string: content, isPlaceholder: true };
+                    this._updateRepr(quiet);
+                }
                 else if (content.treeData) {
                     this._responseParts[responsePosition] = { treeData: content.treeData };
                     this._updateRepr(quiet);
@@ -81,6 +88,9 @@ class Response {
             this._responseParts.push(responsePart);
             this._updateRepr(quiet);
         }
+        else if ('documents' in responsePart) {
+            this._usedContext = responsePart;
+        }
     }
     _updateRepr(quiet) {
         this._responseData = ( this._responseParts.map(part => {
@@ -133,14 +143,15 @@ class ChatResponseModel extends Disposable {
         return this.session.providerId;
     }
     get username() {
-        return this.session.responderUsername;
+        return this.agent?.metadata.fullName ?? this.session.responderUsername;
     }
     get avatarIconUri() {
-        return this.session.responderAvatarIconUri;
+        return this.agent?.metadata.icon ?? this.session.responderAvatarIconUri;
     }
-    constructor(_response, session, _isComplete = false, _isCanceled = false, _vote, _providerResponseId, _errorDetails, _followups) {
+    constructor(_response, session, agent, _isComplete = false, _isCanceled = false, _vote, _providerResponseId, _errorDetails, _followups) {
         super();
         this.session = session;
+        this.agent = agent;
         this._isComplete = _isComplete;
         this._isCanceled = _isCanceled;
         this._vote = _vote;

package/vscode/src/vs/workbench/contrib/chat/common/chatSlashCommands.js

@@ -1,3 +1,80 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { isProposedApiEnabled } from '../../../services/extensions/common/extensions.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+const slashItem = {
+    type: 'object',
+    required: ['command', 'detail'],
+    properties: {
+        command: {
+            type: 'string',
+            markdownDescription: ( localize('command', "The name of the slash command which will be used as prefix."))
+        },
+        detail: {
+            type: 'string',
+            markdownDescription: ( localize('details', "The details of the slash command."))
+        },
+    }
+};
+const slashItems = {
+    description: ( localize(
+        'vscode.extension.contributes.slashes',
+        "Contributes slash commands to chat"
+    )),
+    oneOf: [
+        slashItem,
+        {
+            type: 'array',
+            items: slashItem
+        }
+    ]
+};
+const slashesExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'slashes',
+    jsonSchema: slashItems
+}));
+function isChatSlashData(data) {
+    return typeof data === 'object' && data &&
+        typeof data.command === 'string' &&
+        typeof data.detail === 'string' &&
+        (typeof data.sortText === 'undefined' || typeof data.sortText === 'string') &&
+        (typeof data.executeImmediately === 'undefined' || typeof data.executeImmediately === 'boolean');
+}
 const IChatSlashCommandService = ( createDecorator('chatSlashCommandService'));
-export { IChatSlashCommandService };
+let ChatSlashCommandContribution = class ChatSlashCommandContribution {
+    constructor(slashCommandService) {
+        const contributions = ( new DisposableStore());
+        slashesExtPoint.setHandler(extensions => {
+            contributions.clear();
+            for (const entry of extensions) {
+                if (!isProposedApiEnabled(entry.description, 'chatSlashCommands')) {
+                    entry.collector.error(`The ${slashesExtPoint.name} is proposed API`);
+                    continue;
+                }
+                const { value } = entry;
+                for (const candidate of Iterable.wrap(value)) {
+                    if (!isChatSlashData(candidate)) {
+                        entry.collector.error(( localize(
+                            'invalid',
+                            "Invalid {0}: {1}",
+                            slashesExtPoint.name,
+                            JSON.stringify(candidate)
+                        )));
+                        continue;
+                    }
+                    contributions.add(slashCommandService.registerSlashData({ ...candidate }));
+                }
+            }
+        });
+    }
+};
+ChatSlashCommandContribution = ( __decorate([
+    ( __param(0, IChatSlashCommandService))
+], ChatSlashCommandContribution));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ChatSlashCommandContribution, 3 );
+export { IChatSlashCommandService, slashesExtPoint };

package/vscode/src/vs/workbench/contrib/codeActions/browser/codeActionsContribution.js

@@ -8,14 +8,35 @@ import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+const createCodeActionsAutoSave = (description) => {
+    return {
+        type: ['string', 'boolean'],
+        enum: ['always', 'explicit', 'never', true, false],
+        enumDescriptions: [
+            ( nls.localize(
+                'alwaysSave',
+                'Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes.'
+            )),
+            ( nls.localize('explicitSave', 'Triggers Code Actions only when explicitly saved')),
+            ( nls.localize('neverSave', 'Never triggers Code Actions on save')),
+            ( nls.localize(
+                'explicitSaveBoolean',
+                'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
+            )),
+            ( nls.localize(
+                'neverSaveBoolean',
+                'Never triggers Code Actions on save. This value will be deprecated in favor of "never".'
+            ))
+        ],
+        default: true,
+        description: description
+    };
+};
 const codeActionsOnSaveDefaultProperties = ( Object.freeze({
-    'source.fixAll': {
-        type: 'boolean',
-        description: ( nls.localize(
-            'codeActionsOnSave.fixAll',
-            "Controls whether auto fix action should be run on file save."
-        ))
-    }
+    'source.fixAll': createCodeActionsAutoSave(( nls.localize(
+        'codeActionsOnSave.fixAll',
+        "Controls whether auto fix action should be run on file save."
+    ))),
 }));
 const codeActionsOnSaveSchema = {
     oneOf: [
@@ -23,7 +44,7 @@ const codeActionsOnSaveSchema = {
             type: 'object',
             properties: codeActionsOnSaveDefaultProperties,
             additionalProperties: {
-                type: 'boolean'
+                type: ['string', 'boolean']
             },
         },
         {
@@ -31,8 +52,16 @@ const codeActionsOnSaveSchema = {
             items: { type: 'string' }
         }
     ],
+    markdownDescription: ( nls.localize(
+        'editor.codeActionsOnSave',
+        'Run CodeActions for the editor on save. CodeActions must be specified and the editor must not be shutting down. Example: `"source.organizeImports": "explicit" `'
+    )),
+    type: 'object',
+    additionalProperties: {
+        type: ['string', 'boolean'],
+        enum: ['always', 'explicit', 'never', true, false],
+    },
     default: {},
-    description: ( nls.localize('codeActionsOnSave', "Code Action kinds to be run on save.")),
     scope: 5 ,
 };
 const editorConfiguration = ( Object.freeze({
@@ -59,14 +88,11 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
     updateConfigurationSchema(codeActionContributions) {
         const newProperties = { ...codeActionsOnSaveDefaultProperties };
         for (const [sourceAction, props] of this.getSourceActions(codeActionContributions)) {
-            newProperties[sourceAction] = {
-                type: 'boolean',
-                description: ( nls.localize(
-                    'codeActionsOnSave.generic',
-                    "Controls whether '{0}' actions should be run on file save.",
-                    props.title
-                ))
-            };
+            newProperties[sourceAction] = createCodeActionsAutoSave(( nls.localize(
+                'codeActionsOnSave.generic',
+                "Controls whether '{0}' actions should be run on file save.",
+                props.title
+            )));
         }
         codeActionsOnSaveSchema.properties = newProperties;
         ( Registry.as(Extensions.Configuration))

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorHelper.js

@@ -3,21 +3,22 @@ import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { observableFromEvent, autorunWithStore } from 'monaco-editor/esm/vs/base/common/observable.js';
 import { registerDiffEditorContribution } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { AccessibleDiffViewerNext, AccessibleDiffViewerPrev } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditor.contribution.js';
-import { DiffEditorWidget2 } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditorWidget2/diffEditorWidget2.js';
-import { EmbeddedDiffEditorWidget, EmbeddedDiffEditorWidget2 } from 'monaco-editor/esm/vs/editor/browser/widget/embeddedCodeEditorWidget.js';
+import { AccessibleDiffViewerNext, AccessibleDiffViewerPrev } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditor/diffEditor.contribution.js';
+import { DiffEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditor/diffEditorWidget.js';
+import { EmbeddedDiffEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/embeddedCodeEditorWidget.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ContextKeyExpr, ContextKeyEqualsExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextKeyService, ContextKeyEqualsExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { FloatingEditorClickWidget } from '../../../browser/codeeditor.js';
+import { Extensions } from '../../../common/configuration.js';
+import { getCommentCommandInfo } from '../../accessibility/browser/accessibilityContributions.js';
 import { IAccessibleViewService } from '../../accessibility/browser/accessibleView.js';
 import { AccessibilityHelpAction } from '../../accessibility/browser/accessibleViewActions.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from '../../../common/configuration.js';
 let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Disposable {
     static { this.ID = 'editor.contrib.diffEditorHelper'; }
     constructor(_diffEditor, _instantiationService, _configurationService, _notificationService) {
@@ -27,7 +28,7 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
         this._configurationService = _configurationService;
         this._notificationService = _notificationService;
         this._register(createScreenReaderHelp());
-        const isEmbeddedDiffEditor = (this._diffEditor instanceof EmbeddedDiffEditorWidget) || (this._diffEditor instanceof EmbeddedDiffEditorWidget2);
+        const isEmbeddedDiffEditor = this._diffEditor instanceof EmbeddedDiffEditorWidget;
         if (!isEmbeddedDiffEditor) {
             const computationResult = observableFromEvent(e => this._diffEditor.onDidUpdateDiff(e), () => this._diffEditor.getDiffComputationResult());
             const onlyWhiteSpaceChange = ( computationResult.map(r => r && !r.identical && r.changes2.length === 0));
@@ -69,9 +70,10 @@ function createScreenReaderHelp() {
         const editorService = accessor.get(IEditorService);
         const codeEditorService = accessor.get(ICodeEditorService);
         const keybindingService = accessor.get(IKeybindingService);
+        const contextKeyService = accessor.get(IContextKeyService);
         const next = keybindingService.lookupKeybinding(AccessibleDiffViewerNext.id)?.getAriaLabel();
         const previous = keybindingService.lookupKeybinding(AccessibleDiffViewerPrev.id)?.getAriaLabel();
-        if (!(editorService.activeTextEditorControl instanceof DiffEditorWidget2)) {
+        if (!(editorService.activeTextEditorControl instanceof DiffEditorWidget)) {
             return;
         }
         const codeEditor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
@@ -79,31 +81,33 @@ function createScreenReaderHelp() {
             return;
         }
         const keys = ['audioCues.diffLineDeleted', 'audioCues.diffLineInserted', 'audioCues.diffLineModified'];
+        const content = [
+            ( localize('msg1', "You are in a diff editor.")),
+            ( localize(
+                'msg2',
+                "View the next ({0}) or previous ({1}) diff in diff review mode, which is optimized for screen readers.",
+                next,
+                previous
+            )),
+            ( localize(
+                'msg3',
+                "To control which audio cues should be played, the following settings can be configured: {0}.",
+                keys.join(', ')
+            )),
+        ];
+        const commentCommandInfo = getCommentCommandInfo(keybindingService, contextKeyService, codeEditor);
+        if (commentCommandInfo) {
+            content.push(commentCommandInfo);
+        }
         accessibleViewService.show({
             verbositySettingKey: "accessibility.verbosity.diffEditor" ,
-            provideContent: () => [
-                ( localize('msg1', "You are in a diff editor.")),
-                ( localize(
-                    'msg2',
-                    "Press {0} or {1} to view the next or previous diff in the diff review mode that is optimized for screen readers.",
-                    next,
-                    previous
-                )),
-                ( localize(
-                    'msg3',
-                    "To control which audio cues should be played, the following settings can be configured: {0}.",
-                    keys.join(', ')
-                )),
-            ].join('\n\n'),
+            provideContent: () => content.join('\n\n'),
             onClose: () => {
                 codeEditor.focus();
             },
             options: { type: "help"  }
         });
-    }, ( ContextKeyExpr.and(
-        ContextKeyEqualsExpr.create('diffEditorVersion', 2),
-        ContextKeyEqualsExpr.create('isInDiffEditor', true)
-    )));
+    }, ContextKeyEqualsExpr.create('isInDiffEditor', true));
 }
 registerDiffEditorContribution(DiffEditorHelperContribution.ID, DiffEditorHelperContribution);
 ( Registry.as(Extensions.ConfigurationMigration))

package/vscode/src/vs/workbench/contrib/codeEditor/browser/largeFileOptimizations.js

@@ -26,7 +26,7 @@ let LargeFileOptimizationsWarner = class LargeFileOptimizationsWarner extends Di
                 comment: [
                     'Variable 0 will be a file name.'
                 ]
-            }, "{0}: tokenization, wrapping, folding and sticky scroll have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.", path.basename(model.uri.path)));
+            }, "{0}: tokenization, wrapping, folding, codelens, word highlighting and sticky scroll have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.", path.basename(model.uri.path)));
             this._notificationService.prompt(Severity.Info, message, [
                 {
                     label: ( nls.localize('removeOptimizations', "Forcefully Enable Features")),

package/vscode/src/vs/workbench/contrib/codeEditor/browser/saveParticipants.js

@@ -1,4 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
 import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
@@ -6,6 +7,7 @@ import { trimTrailingWhitespace } from 'monaco-editor/esm/vs/editor/common/comma
 import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
 import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
 import { applyCodeAction, ApplyCodeActionReason, getCodeActions } from 'monaco-editor/esm/vs/editor/contrib/codeAction/browser/codeAction.js';
 import { CodeActionKind, CodeActionTriggerSource } from 'monaco-editor/esm/vs/editor/contrib/codeAction/common/types.js';
 import { formatDocumentWithSelectedProvider, formatDocumentRangesWithSelectedProvider } from 'monaco-editor/esm/vs/editor/contrib/format/browser/format.js';
@@ -14,12 +16,10 @@ import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Extensions } from '../../../common/contributions.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
 import { getModifiedRanges } from '../../format/browser/formatModified.js';
-import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
 let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
     constructor(configurationService, codeEditorService) {
         this.configurationService = configurationService;
@@ -223,19 +223,25 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         if (!model.textEditorModel) {
             return;
         }
-        if (env.reason !== 1 ) {
-            return undefined;
-        }
         const textEditorModel = model.textEditorModel;
-        const settingsOverrides = { overrideIdentifier: textEditorModel.getLanguageId(), resource: model.resource };
+        const settingsOverrides = { overrideIdentifier: textEditorModel.getLanguageId(), resource: textEditorModel.uri };
         const setting = this.configurationService.getValue('editor.codeActionsOnSave', settingsOverrides);
         if (!setting) {
             return undefined;
         }
-        const settingItems = Array.isArray(setting)
-            ? setting
-            : ( Object.keys(setting)).filter(x => setting[x]);
-        const codeActionsOnSave = this.createCodeActionsOnSave(settingItems);
+        if (env.reason === 2 ) {
+            return undefined;
+        }
+        const convertedSetting = {};
+        for (const key in setting) {
+            if (typeof setting[key] === 'boolean') {
+                convertedSetting[key] = setting[key] ? 'explicit' : 'never';
+            }
+            else if (typeof setting[key] === 'string') {
+                convertedSetting[key] = setting[key];
+            }
+        }
+        const codeActionsOnSave = this.createCodeActionsOnSave(( Object.keys(convertedSetting)));
         if (!Array.isArray(setting)) {
             codeActionsOnSave.sort((a, b) => {
                 if (CodeActionKind.SourceFixAll.contains(a)) {
@@ -253,13 +259,12 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         if (!codeActionsOnSave.length) {
             return undefined;
         }
-        const excludedActions = Array.isArray(setting)
-            ? []
-            : ( ( Object.keys(setting))
-                .filter(x => setting[x] === false)
-                .map(x => ( new CodeActionKind(x))));
+        const excludedActions = ( ( Object.keys(setting))
+            .filter(x => convertedSetting[x] === 'never' || false)
+            .map(x => ( new CodeActionKind(x))));
         progress.report({ message: ( localize('codeaction', "Quick Fixes")) });
-        await this.applyOnSaveActions(textEditorModel, codeActionsOnSave, excludedActions, progress, token);
+        const filteredSaveList = codeActionsOnSave.filter(x => convertedSetting[x.value] === 'always' || (convertedSetting[x.value] === 'explicit') && env.reason === 1 );
+        await this.applyOnSaveActions(textEditorModel, filteredSaveList, excludedActions, progress, token);
     }
     createCodeActionsOnSave(settingItems) {
         const kinds = ( settingItems.map(x => ( new CodeActionKind(x))));