Implement "code actions on save" (#15555)

Fixes #14955

Contributed on behalf of STMicroelectronics

Author: tsmaeder

CHANGELOG.md

@@ -3,6 +3,13 @@
 ## History
 
 - [Previous Changelogs](https://github.com/eclipse-theia/theia/tree/master/doc/changelogs/)
+## 1.62.0 - 
+
+<a name="breaking_changes_1.62.0">[Breaking Changes:](#breaking_changes_1.62.0)</a>
+
+- [monaco] Implement "code actions on save" [#15555](https://github.com/eclipse-theia/theia/pull/15555)
+  Replaced `MonacoEditorModel.onWillSave` "wait until event" event with `registerWillSaveModelListener` for simpler semantics. Also removed the `EditorModelService.onWillSave`
+  as it's pure convenience and unused in framework code.
 
 ## 1.62.0 - 
 

packages/monaco/src/browser/monaco-code-action-save-participant.ts

@@ -0,0 +1,143 @@
+// *****************************************************************************
+// Copyright (C) 2025 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { CancellationToken } from '@theia/core';
+import { SaveOptions, SaveReason } from '@theia/core/lib/browser';
+import { MonacoEditor } from './monaco-editor';
+import { SaveParticipant, SAVE_PARTICIPANT_DEFAULT_ORDER } from './monaco-editor-provider';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { ILanguageFeaturesService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures';
+import { CodeActionKind, CodeActionSet, CodeActionTriggerSource } from '@theia/monaco-editor-core/esm/vs/editor/contrib/codeAction/common/types';
+import { applyCodeAction, ApplyCodeActionReason, getCodeActions } from '@theia/monaco-editor-core/esm/vs/editor/contrib/codeAction/browser/codeAction';
+
+import { HierarchicalKind } from '@theia/monaco-editor-core/esm/vs/base/common/hierarchicalKind';
+import { EditorPreferences } from '@theia/editor/lib/browser';
+import { ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { CodeActionProvider, CodeActionTriggerType } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
+import { IProgress } from '@theia/monaco-editor-core/esm/vs/platform/progress/common/progress';
+import { IInstantiationService } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Partially copied from https://github.com/microsoft/vscode/blob/f66e839a38dfe39ee66a86619a790f9c2336d698/src/vs/workbench/contrib/codeEditor/browser/saveParticipants.ts#L272
+@injectable()
+export class MonacoCodeActionSaveParticipant implements SaveParticipant {
+    @inject(EditorPreferences)
+    protected readonly editorPreferences: EditorPreferences;
+
+    readonly order = SAVE_PARTICIPANT_DEFAULT_ORDER;
+
+    async applyChangesOnSave(editor: MonacoEditor, cancellationToken: CancellationToken, options?: SaveOptions): Promise<void> {
+        if (options?.saveReason !== SaveReason.Manual) {
+            return undefined;
+        }
+
+        const setting = this.editorPreferences.get({
+            preferenceName: 'editor.codeActionsOnSave',
+            overrideIdentifier: editor.document.textEditorModel.getLanguageId()
+        }, undefined, editor.document.textEditorModel.uri.toString());
+
+        if (!setting) {
+            return undefined;
+        }
+
+        const settingItems: string[] = Array.isArray(setting)
+            ? setting
+            : Object.keys(setting).filter(x => setting[x]);
+
+        const codeActionsOnSave = this.createCodeActionsOnSave(settingItems);
+
+        if (!codeActionsOnSave.length) {
+            return undefined;
+        }
+
+        if (!Array.isArray(setting)) {
+            codeActionsOnSave.sort((a, b) => {
+                if (CodeActionKind.SourceFixAll.contains(a)) {
+                    if (CodeActionKind.SourceFixAll.contains(b)) {
+                        return 0;
+                    }
+                    return -1;
+                }
+                if (CodeActionKind.SourceFixAll.contains(b)) {
+                    return 1;
+                }
+                return 0;
+            });
+        }
+
+        const excludedActions = Array.isArray(setting)
+            ? []
+            : Object.keys(setting)
+                .filter(x => setting[x] === false)
+                .map(x => new HierarchicalKind(x));
+
+        await this.applyOnSaveActions(editor.document.textEditorModel, codeActionsOnSave, excludedActions, cancellationToken);
+    }
+
+    private createCodeActionsOnSave(settingItems: readonly string[]): HierarchicalKind[] {
+        const kinds = settingItems.map(x => new HierarchicalKind(x));
+
+        // Remove subsets
+        return kinds.filter(kind => kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind)));
+    }
+
+    private async applyOnSaveActions(model: ITextModel, codeActionsOnSave: readonly HierarchicalKind[],
+        excludes: readonly HierarchicalKind[], token: CancellationToken): Promise<void> {
+
+        const instantiationService = StandaloneServices.get(IInstantiationService);
+
+        for (const codeActionKind of codeActionsOnSave) {
+            const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludes, token);
+
+            if (token.isCancellationRequested) {
+                actionsToRun.dispose();
+                return;
+            }
+
+            try {
+                for (const action of actionsToRun.validActions) {
+                    await instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                }
+            } catch {
+                // Failure to apply a code action should not block other on save actions
+            } finally {
+                actionsToRun.dispose();
+            }
+        }
+    }
+
+    private getActionsToRun(model: ITextModel, codeActionKind: HierarchicalKind, excludes: readonly HierarchicalKind[], token: CancellationToken): Promise<CodeActionSet> {
+        const { codeActionProvider } = StandaloneServices.get(ILanguageFeaturesService);
+
+        const progress: IProgress<CodeActionProvider> = {
+            report(item): void {
+                // empty
+            },
+        };
+
+        return getCodeActions(codeActionProvider, model, model.getFullModelRange(), {
+            type: CodeActionTriggerType.Auto,
+            triggerAction: CodeActionTriggerSource.OnSave,
+            filter: { include: codeActionKind, excludes: excludes, includeSourceActions: true },
+        }, progress, token);
+    }
+}

packages/monaco/src/browser/monaco-editor-model.ts

@@ -20,11 +20,11 @@ import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposa
 import { Emitter, Event } from '@theia/core/lib/common/event';
 import { CancellationTokenSource, CancellationToken } from '@theia/core/lib/common/cancellation';
 import { Resource, ResourceError, ResourceVersion } from '@theia/core/lib/common/resource';
-import { Saveable, SaveOptions } from '@theia/core/lib/browser/saveable';
+import { Saveable, SaveOptions, SaveReason } from '@theia/core/lib/browser/saveable';
 import { MonacoToProtocolConverter } from './monaco-to-protocol-converter';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
 import { ILogger, Loggable, Log } from '@theia/core/lib/common/logger';
-import { IIdentifiedSingleEditOperation, ITextBufferFactory, ITextModel, ITextSnapshot } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { ITextBufferFactory, ITextModel, ITextSnapshot } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
 import { IResolvedTextEditorModel } from '@theia/monaco-editor-core/esm/vs/editor/common/services/resolverService';
 import * as monaco from '@theia/monaco-editor-core';
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
@@ -39,12 +39,7 @@ export {
     TextDocumentSaveReason
 };
 
-export interface WillSaveMonacoModelEvent {
-    readonly model: MonacoEditorModel;
-    readonly reason: TextDocumentSaveReason;
-    readonly options?: SaveOptions;
-    waitUntil(thenable: Thenable<IIdentifiedSingleEditOperation[]>): void;
-}
+export type WillSaveMonacoModelListener = (model: MonacoEditorModel, token: CancellationToken, options?: SaveOptions) => Promise<void>;
 
 export interface MonacoModelContentChangedEvent {
     readonly model: MonacoEditorModel;
@@ -83,9 +78,6 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
     protected readonly onDidSaveModelEmitter = new Emitter<ITextModel>();
     readonly onDidSaveModel = this.onDidSaveModelEmitter.event;
 
-    protected readonly onWillSaveModelEmitter = new Emitter<WillSaveMonacoModelEvent>();
-    readonly onWillSaveModel = this.onWillSaveModelEmitter.event;
-
     protected readonly onDidChangeValidEmitter = new Emitter<void>();
     readonly onDidChangeValid = this.onDidChangeValidEmitter.event;
 
@@ -99,6 +91,8 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
 
     protected resourceVersion: ResourceVersion | undefined;
 
+    protected readonly willSaveModelListeners: WillSaveMonacoModelListener[] = [];
+
     constructor(
         protected readonly resource: Resource,
         protected readonly m2p: MonacoToProtocolConverter,
@@ -110,7 +104,6 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
         this.toDispose.push(this.toDisposeOnAutoSave);
         this.toDispose.push(this.onDidChangeContentEmitter);
         this.toDispose.push(this.onDidSaveModelEmitter);
-        this.toDispose.push(this.onWillSaveModelEmitter);
         this.toDispose.push(this.onDirtyChangedEmitter);
         this.toDispose.push(this.onDidChangeValidEmitter);
         this.toDispose.push(Disposable.create(() => this.cancelSave()));
@@ -154,7 +147,7 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
         if (mode === EncodingMode.Decode) {
             return this.sync();
         }
-        return this.scheduleSave(TextDocumentSaveReason.Manual, this.cancelSave(), true);
+        return this.scheduleSave(this.cancelSave(), true, { saveReason: SaveReason.Manual });
     }
 
     getEncoding(): string | undefined {
@@ -386,7 +379,10 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
     }
 
     save(options?: SaveOptions): Promise<void> {
-        return this.scheduleSave(options?.saveReason ?? TextDocumentSaveReason.Manual, undefined, undefined, options);
+        return this.scheduleSave(undefined, undefined, {
+            saveReason: TextDocumentSaveReason.Manual,
+            ...options
+        });
     }
 
     protected pendingOperation = Promise.resolve();
@@ -485,8 +481,8 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
         return this.saveCancellationTokenSource.token;
     }
 
-    protected scheduleSave(reason: TextDocumentSaveReason, token: CancellationToken = this.cancelSave(), overwriteEncoding?: boolean, options?: SaveOptions): Promise<void> {
-        return this.run(() => this.doSave(reason, token, overwriteEncoding, options));
+    protected scheduleSave(token: CancellationToken = this.cancelSave(), overwriteEncoding?: boolean, options?: SaveOptions): Promise<void> {
+        return this.run(() => this.doSave(token, overwriteEncoding, options));
     }
 
     protected ignoreContentChanges = false;
@@ -546,18 +542,18 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
         }
     }
 
-    protected async doSave(reason: TextDocumentSaveReason, token: CancellationToken, overwriteEncoding?: boolean, options?: SaveOptions): Promise<void> {
+    protected async doSave(token: CancellationToken, overwriteEncoding?: boolean, options?: SaveOptions): Promise<void> {
         if (token.isCancellationRequested || !this.resource.saveContents) {
             return;
         }
 
-        await this.fireWillSaveModel(reason, token, options);
+        await this.fireWillSaveModel(token, options);
         if (token.isCancellationRequested) {
             return;
         }
 
         const changes = [...this.contentChanges];
-        if ((changes.length === 0 && !this.resource.initiallyDirty) && !overwriteEncoding && reason !== TextDocumentSaveReason.Manual) {
+        if ((changes.length === 0 && !this.resource.initiallyDirty) && !overwriteEncoding && options?.saveReason !== TextDocumentSaveReason.Manual) {
             return;
         }
 
@@ -586,64 +582,19 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
         }
     }
 
-    protected async fireWillSaveModel(reason: TextDocumentSaveReason, token: CancellationToken, options?: SaveOptions): Promise<void> {
-        type EditContributor = Thenable<monaco.editor.IIdentifiedSingleEditOperation[]>;
-
-        const firing = this.onWillSaveModelEmitter.sequence(async listener => {
-            if (token.isCancellationRequested) {
-                return false;
-            }
-            const waitables: EditContributor[] = [];
-            const { version } = this;
-
-            const event = {
-                model: this, reason, options,
-                waitUntil: (thenable: EditContributor) => {
-                    if (Object.isFrozen(waitables)) {
-                        throw new Error('waitUntil cannot be called asynchronously.');
-                    }
-                    waitables.push(thenable);
-                }
-            };
-
-            // Fire.
-            try {
-                listener(event);
-            } catch (err) {
-                console.error(err);
-                return true;
-            }
-
-            // Asynchronous calls to `waitUntil` should fail.
-            Object.freeze(waitables);
-
-            // Wait for all promises.
-            const edits = await Promise.all(waitables).then(allOperations =>
-                ([] as monaco.editor.IIdentifiedSingleEditOperation[]).concat(...allOperations)
-            );
-            if (token.isCancellationRequested) {
-                return false;
-            }
-
-            // In a perfect world, we should only apply edits if document is clean.
-            if (version !== this.version) {
-                console.error('onWillSave listeners should provide edits, not directly alter the document.');
-            }
-
-            // Finally apply edits provided by this listener before firing the next.
-            if (edits && edits.length > 0) {
-                this.applyEdits(edits, {
-                    ignoreDirty: true,
-                });
+    registerWillSaveModelListener(listener: WillSaveMonacoModelListener): Disposable {
+        this.willSaveModelListeners.push(listener);
+        return Disposable.create(() => {
+            const index = this.willSaveModelListeners.indexOf(listener);
+            if (index >= 0) {
+                this.willSaveModelListeners.splice(index, 1);
             }
-
-            return true;
         });
+    }
 
-        try {
-            await firing;
-        } catch (e) {
-            console.error(e);
+    protected async fireWillSaveModel(token: CancellationToken, options?: SaveOptions): Promise<void> {
+        for (const listener of this.willSaveModelListeners) {
+            await listener(this, token, options);
         }
     }