@theia/monaco 1.62.0-next.3 → 1.62.0

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@theia/monaco",
-  "version": "1.62.0-next.3+907647f99",
+  "version": "1.62.0",
   "description": "Theia - Monaco Extension",
   "dependencies": {
-    "@theia/core": "1.62.0-next.3+907647f99",
-    "@theia/editor": "1.62.0-next.3+907647f99",
-    "@theia/filesystem": "1.62.0-next.3+907647f99",
-    "@theia/markers": "1.62.0-next.3+907647f99",
+    "@theia/core": "1.62.0",
+    "@theia/editor": "1.62.0",
+    "@theia/filesystem": "1.62.0",
+    "@theia/markers": "1.62.0",
     "@theia/monaco-editor-core": "1.96.302",
-    "@theia/outline-view": "1.62.0-next.3+907647f99",
-    "@theia/workspace": "1.62.0-next.3+907647f99",
+    "@theia/outline-view": "1.62.0",
+    "@theia/workspace": "1.62.0",
     "fast-plist": "^0.1.2",
     "idb": "^4.0.5",
     "jsonc-parser": "^2.2.0",
@@ -52,10 +52,10 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.61.0"
+    "@theia/ext-scripts": "1.62.0"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "907647f99bd78541b18e8e6133acc9246d85a8a2"
+  "gitHead": "a4e035ccc26fde24c2769a466cb18e3b54c517c5"
 }

package/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);
+    }
+}

package/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);
         }
     }
 

package/src/browser/monaco-editor-provider.ts

@@ -18,26 +18,23 @@
 import URI from '@theia/core/lib/common/uri';
 import { EditorPreferenceChange, EditorPreferences, TextEditor, DiffNavigator } from '@theia/editor/lib/browser';
 import { DiffUris } from '@theia/core/lib/browser/diff-uris';
-import { inject, injectable, named } from '@theia/core/shared/inversify';
-import { DisposableCollection, deepClone, Disposable } from '@theia/core/lib/common';
-import { TextDocumentSaveReason } from '@theia/core/shared/vscode-languageserver-protocol';
+import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
+import { DisposableCollection, deepClone, Disposable, CancellationToken } from '@theia/core/lib/common';
 import { MonacoDiffEditor } from './monaco-diff-editor';
 import { MonacoDiffNavigatorFactory } from './monaco-diff-navigator-factory';
 import { EditorServiceOverrides, MonacoEditor, MonacoEditorServices } from './monaco-editor';
-import { MonacoEditorModel, WillSaveMonacoModelEvent } from './monaco-editor-model';
+import { MonacoEditorModel, TextDocumentSaveReason } from './monaco-editor-model';
 import { MonacoWorkspace } from './monaco-workspace';
 import { ContributionProvider } from '@theia/core';
-import { KeybindingRegistry, OpenerService, open, WidgetOpenerOptions, FormatType } from '@theia/core/lib/browser';
+import { KeybindingRegistry, OpenerService, open, WidgetOpenerOptions, SaveOptions, FormatType } from '@theia/core/lib/browser';
 import { MonacoResolvedKeybinding } from './monaco-resolved-keybinding';
 import { HttpOpenHandlerOptions } from '@theia/core/lib/browser/http-open-handler';
 import { MonacoToProtocolConverter } from './monaco-to-protocol-converter';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
-import { FileSystemPreferences } from '@theia/filesystem/lib/browser';
 import * as monaco from '@theia/monaco-editor-core';
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { IOpenerService, OpenExternalOptions, OpenInternalOptions } from '@theia/monaco-editor-core/esm/vs/platform/opener/common/opener';
 import { IKeybindingService } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybinding';
-import { timeoutReject } from '@theia/core/lib/common/promise-util';
 import { IContextMenuService } from '@theia/monaco-editor-core/esm/vs/platform/contextview/browser/contextView';
 import { KeyCodeChord } from '@theia/monaco-editor-core/esm/vs/base/common/keybindings';
 import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
@@ -46,6 +43,8 @@ import { IReference } from '@theia/monaco-editor-core/esm/vs/base/common/lifecyc
 import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 import { SimpleMonacoEditor } from './simple-monaco-editor';
 import { ICodeEditorWidgetOptions } from '@theia/monaco-editor-core/esm/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { timeoutReject } from '@theia/core/lib/common/promise-util';
+import { FileSystemPreferences } from '@theia/filesystem/lib/browser';
 
 export const MonacoEditorFactory = Symbol('MonacoEditorFactory');
 export interface MonacoEditorFactory {
@@ -53,6 +52,17 @@ export interface MonacoEditorFactory {
     create(model: MonacoEditorModel, defaultOptions: MonacoEditor.IOptions, defaultOverrides: EditorServiceOverrides): Promise<MonacoEditor>;
 }
 
+export const SaveParticipant = Symbol('SaveParticipant');
+
+export interface SaveParticipant {
+    readonly order: number;
+    applyChangesOnSave(
+        editor: MonacoEditor,
+        cancellationToken: CancellationToken,
+        options?: SaveOptions): Promise<void>;
+}
+export const SAVE_PARTICIPANT_DEFAULT_ORDER = 0;
+
 @injectable()
 export class MonacoEditorProvider {
 
@@ -68,9 +78,13 @@ export class MonacoEditorProvider {
 
     @inject(OpenerService)
     protected readonly openerService: OpenerService;
+    @inject(ContributionProvider)
+    @named(SaveParticipant)
+    protected readonly saveProviderContributions: ContributionProvider<SaveParticipant>;
 
     @inject(FileSystemPreferences)
     protected readonly filePreferences: FileSystemPreferences;
+    protected saveParticipants: SaveParticipant[];
 
     protected _current: MonacoEditor | undefined;
     /**
@@ -210,7 +224,7 @@ export class MonacoEditorProvider {
         }));
         toDispose.push(editor.onLanguageChanged(() => this.updateMonacoEditorOptions(editor)));
         toDispose.push(editor.onDidChangeReadOnly(() => this.updateReadOnlyMessage(options, model.readOnly)));
-        editor.document.onWillSaveModel(event => event.waitUntil(this.formatOnSave(editor, event)));
+        toDispose.push(editor.document.registerWillSaveModelListener((_, token, o) => this.runSaveParticipants(editor, token, o)));
         return editor;
     }
 
@@ -239,46 +253,6 @@ export class MonacoEditorProvider {
         }
     }
 
-    protected shouldFormat(editor: MonacoEditor, event: WillSaveMonacoModelEvent): boolean {
-        if (event.reason !== TextDocumentSaveReason.Manual) {
-            return false;
-        }
-        if (event.options?.formatType) {
-            switch (event.options.formatType) {
-                case FormatType.ON: return true;
-                case FormatType.OFF: return false;
-                case FormatType.DIRTY: return editor.document.dirty;
-            }
-        }
-        return true;
-    }
-
-    protected async formatOnSave(editor: MonacoEditor, event: WillSaveMonacoModelEvent): Promise<monaco.editor.IIdentifiedSingleEditOperation[]> {
-        if (!this.shouldFormat(editor, event)) {
-            return [];
-        }
-        const edits: monaco.editor.IIdentifiedSingleEditOperation[] = [];
-        const overrideIdentifier = editor.document.languageId;
-        const uri = editor.uri.toString();
-        const formatOnSave = this.editorPreferences.get({ preferenceName: 'editor.formatOnSave', overrideIdentifier }, undefined, uri);
-        if (formatOnSave) {
-            const formatOnSaveTimeout = this.editorPreferences.get({ preferenceName: 'editor.formatOnSaveTimeout', overrideIdentifier }, undefined, uri)!;
-            await Promise.race([
-                timeoutReject(formatOnSaveTimeout, `Aborted format on save after ${formatOnSaveTimeout}ms`),
-                editor.runAction('editor.action.formatDocument')
-            ]);
-        }
-        const shouldRemoveWhiteSpace = this.filePreferences.get({ preferenceName: 'files.trimTrailingWhitespace', overrideIdentifier }, undefined, uri);
-        if (shouldRemoveWhiteSpace) {
-            await editor.runAction('editor.action.trimTrailingWhitespace');
-        }
-        const insertFinalNewline = this.filePreferences.get({ preferenceName: 'files.insertFinalNewline', overrideIdentifier }, undefined, uri);
-        if (insertFinalNewline) {
-            edits.push(...this.insertFinalNewline(editor));
-        }
-        return edits;
-    }
-
     protected get diffPreferencePrefixes(): string[] {
         return [...this.preferencePrefixes, 'diffEditor.'];
     }
@@ -497,20 +471,106 @@ export class MonacoEditorProvider {
         );
     }
 
-    protected insertFinalNewline(editor: MonacoEditor): monaco.editor.IIdentifiedSingleEditOperation[] {
-        const model = editor.document && editor.document.textEditorModel;
+    @postConstruct()
+    init(): void {
+        this.saveParticipants = this.saveProviderContributions.getContributions().slice().sort((left, right) => left.order - right.order);
+        this.registerSaveParticipant({
+            order: 1000,
+            applyChangesOnSave: (
+                editor: MonacoEditor,
+                cancellationToken: monaco.CancellationToken,
+                options: SaveOptions): Promise<void> => this.formatOnSave(editor, editor.document, cancellationToken, options)
+        });
+    }
+
+    registerSaveParticipant(saveParticipant: SaveParticipant): Disposable {
+        if (this.saveParticipants.find(value => value === saveParticipant)) {
+            throw new Error('Save participant already registered');
+        }
+        this.saveParticipants.push(saveParticipant);
+        this.saveParticipants.sort((left, right) => left.order - right.order);
+        return Disposable.create(() => {
+            const index = this.saveParticipants.indexOf(saveParticipant);
+            if (index >= 0) {
+                this.saveParticipants.splice(index, 1);
+            }
+        });
+    }
+
+    protected shouldFormat(model: MonacoEditorModel, options: SaveOptions): boolean {
+        if (options.saveReason !== TextDocumentSaveReason.Manual) {
+            return false;
+        }
+        switch (options.formatType) {
+            case FormatType.ON: return true;
+            case FormatType.OFF: return false;
+            case FormatType.DIRTY: return model.dirty;
+        }
+        return true;
+    }
+
+    async runSaveParticipants(editor: MonacoEditor, cancellationToken: CancellationToken, options?: SaveOptions): Promise<void> {
+        const initialState = editor.document.createSnapshot();
+        for (const participant of this.saveParticipants) {
+            if (cancellationToken.isCancellationRequested) {
+                break;
+            }
+            const snapshot = editor.document.createSnapshot();
+            try {
+                await participant.applyChangesOnSave(editor, cancellationToken, options);
+            } catch (e) {
+                console.error(e);
+                editor.document.applySnapshot(snapshot);
+            }
+        }
+        if (cancellationToken.isCancellationRequested) {
+            editor.document.applySnapshot(initialState);
+        }
+    }
+
+    protected async formatOnSave(
+        editor: MonacoEditor,
+        model: MonacoEditorModel,
+        cancellationToken: CancellationToken,
+        options: SaveOptions): Promise<void> {
+        if (!this.shouldFormat(model, options)) {
+            return;
+        }
+
+        const overrideIdentifier = model.languageId;
+        const uri = model.uri.toString();
+        const formatOnSave = this.editorPreferences.get({ preferenceName: 'editor.formatOnSave', overrideIdentifier }, undefined, uri);
+        if (formatOnSave) {
+            const formatOnSaveTimeout = this.editorPreferences.get({ preferenceName: 'editor.formatOnSaveTimeout', overrideIdentifier }, undefined, uri)!;
+            await Promise.race([
+                timeoutReject(formatOnSaveTimeout, `Aborted format on save after ${formatOnSaveTimeout}ms`),
+                await editor.runAction('editor.action.formatDocument')
+            ]);
+        }
+        const shouldRemoveWhiteSpace = this.filePreferences.get({ preferenceName: 'files.trimTrailingWhitespace', overrideIdentifier }, undefined, uri);
+        if (shouldRemoveWhiteSpace) {
+            await editor.runAction('editor.action.trimTrailingWhitespace');
+        }
+        const insertFinalNewline = this.filePreferences.get({ preferenceName: 'files.insertFinalNewline', overrideIdentifier }, undefined, uri);
+        if (insertFinalNewline) {
+            this.insertFinalNewline(model);
+        }
+    }
+
+    protected insertFinalNewline(editorModel: MonacoEditorModel): void {
+        const model = editorModel.textEditorModel;
         if (!model) {
-            return [];
+            return;
         }
 
         const lines = model?.getLineCount();
         if (lines === 0) {
-            return [];
+            return;
         }
 
         const lastLine = model?.getLineContent(lines);
         if (lastLine.trim() === '') {
-            return [];
+            return;
         }
 
         const lastLineMaxColumn = model?.getLineMaxColumn(lines);
@@ -520,9 +580,9 @@ export class MonacoEditorProvider {
             endLineNumber: lines,
             endColumn: lastLineMaxColumn
         };
-        return [{
+        model.applyEdits([{
             range,
             text: model?.getEOL()
-        }];
+        }]);
     }
 }

package/src/browser/monaco-frontend-module.ts

@@ -25,7 +25,7 @@ import {
     WidgetStatusBarContribution
 } from '@theia/core/lib/browser';
 import { TextEditorProvider, DiffNavigatorProvider, TextEditor } from '@theia/editor/lib/browser';
-import { MonacoEditorProvider, MonacoEditorFactory } from './monaco-editor-provider';
+import { MonacoEditorProvider, MonacoEditorFactory, SaveParticipant } from './monaco-editor-provider';
 import { MonacoEditorMenuContribution } from './monaco-menu';
 import { MonacoEditorCommandHandlers } from './monaco-command';
 import { MonacoKeybindingContribution } from './monaco-keybinding';
@@ -79,6 +79,7 @@ import { ActiveMonacoUndoRedoHandler, FocusedMonacoUndoRedoHandler } from './mon
 import { ILogService } from '@theia/monaco-editor-core/esm/vs/platform/log/common/log';
 import { DefaultContentHoverWidgetPatcher } from './default-content-hover-widget-patcher';
 import { MonacoWorkspaceContextService } from './monaco-workspace-context-service';
+import { MonacoCodeActionSaveParticipant } from './monaco-code-action-save-participant';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(MonacoThemingService).toSelf().inSingletonScope();
@@ -91,6 +92,9 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(FrontendApplicationContribution).toService(MonacoFrontendApplicationContribution);
     bind(StylingParticipant).toService(MonacoFrontendApplicationContribution);
 
+    bind(MonacoCodeActionSaveParticipant).toSelf().inSingletonScope();
+    bind(SaveParticipant).toService(MonacoCodeActionSaveParticipant);
+
     bind(MonacoToProtocolConverter).toSelf().inSingletonScope();
     bind(ProtocolToMonacoConverter).toSelf().inSingletonScope();
 
@@ -122,6 +126,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bindContributionProvider(bind, MonacoEditorFactory);
     bindContributionProvider(bind, MonacoEditorModelFactory);
     bindContributionProvider(bind, MonacoEditorModelFilter);
+    bindContributionProvider(bind, SaveParticipant);
     bind(MonacoCommandService).toSelf().inTransientScope();
 
     bind(TextEditorProvider).toProvider(context =>