@theia/plugin-ext 1.61.0 → 1.62.0

package/src/main/browser/documents-main.ts

@@ -16,14 +16,14 @@
 import { DocumentsMain, MAIN_RPC_CONTEXT, DocumentsExt } from '../../common/plugin-api-rpc';
 import { UriComponents } from '../../common/uri-components';
 import { EditorsAndDocumentsMain } from './editors-and-documents-main';
-import { DisposableCollection, Disposable, UntitledResourceResolver } from '@theia/core';
+import { DisposableCollection, Disposable, UntitledResourceResolver, CancellationToken } from '@theia/core';
 import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { EditorModelService } from './text-editor-model-service';
 import { EditorOpenerOptions } from '@theia/editor/lib/browser';
 import URI from '@theia/core/lib/common/uri';
 import { URI as CodeURI } from '@theia/core/shared/vscode-uri';
-import { ApplicationShell } from '@theia/core/lib/browser';
+import { ApplicationShell, SaveOptions, SaveReason } from '@theia/core/lib/browser';
 import { TextDocumentShowOptions } from '../../common/plugin-api-rpc-model';
 import { Range } from '@theia/core/shared/vscode-languageserver-protocol';
 import { OpenerService } from '@theia/core/lib/browser/opener-service';
@@ -33,6 +33,8 @@ import { MonacoLanguages } from '@theia/monaco/lib/browser/monaco-languages';
 import * as monaco from '@theia/monaco-editor-core';
 import { TextDocumentChangeReason } from '../../plugin/types-impl';
 import { NotebookDocumentsMainImpl } from './notebooks/notebook-documents-main';
+import { MonacoEditorProvider, SAVE_PARTICIPANT_DEFAULT_ORDER } from '@theia/monaco/lib/browser/monaco-editor-provider';
+import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -98,6 +100,7 @@ export class DocumentsMainImpl implements DocumentsMain, Disposable {
         private shell: ApplicationShell,
         private untitledResourceResolver: UntitledResourceResolver,
         private languageService: MonacoLanguages,
+        monacoEditorProvider: MonacoEditorProvider
     ) {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.DOCUMENTS_EXT);
 
@@ -111,10 +114,16 @@ export class DocumentsMainImpl implements DocumentsMain, Disposable {
         this.toDispose.push(modelService.onModelSaved(m => {
             this.proxy.$acceptModelSaved(m.textEditorModel.uri);
         }));
-        this.toDispose.push(modelService.onModelWillSave(onWillSaveModelEvent => {
-            onWillSaveModelEvent.waitUntil(new Promise<monaco.editor.IIdentifiedSingleEditOperation[]>(async (resolve, reject) => {
-                setTimeout(() => reject(new Error(`Aborted onWillSaveTextDocument-event after ${this.saveTimeout}ms`)), this.saveTimeout);
-                const edits = await this.proxy.$acceptModelWillSave(onWillSaveModelEvent.model.textEditorModel.uri, onWillSaveModelEvent.reason, this.saveTimeout);
+        this.toDispose.push(monacoEditorProvider.registerSaveParticipant(({
+            order: SAVE_PARTICIPANT_DEFAULT_ORDER,
+            applyChangesOnSave: async (
+                editor: MonacoEditor,
+                cancellationToken: CancellationToken,
+                options: SaveOptions): Promise<void> => {
+
+                const saveReason = options.saveReason ?? SaveReason.Manual;
+
+                const edits = await this.proxy.$acceptModelWillSave(editor.uri.toComponents(), saveReason.valueOf(), this.saveTimeout);
                 const editOperations: monaco.editor.IIdentifiedSingleEditOperation[] = [];
                 for (const edit of edits) {
                     const { range, text } = edit;
@@ -126,15 +135,15 @@ export class DocumentsMainImpl implements DocumentsMain, Disposable {
                     }
 
                     editOperations.push({
-                        range: range ? monaco.Range.lift(range) : onWillSaveModelEvent.model.textEditorModel.getFullModelRange(),
+                        range: range ? monaco.Range.lift(range) : editor.document.textEditorModel.getFullModelRange(),
                         /* eslint-disable-next-line no-null/no-null */
                         text: text || null,
                         forceMoveMarkers: edit.forceMoveMarkers
                     });
                 }
-                resolve(editOperations);
-            }));
-        }));
+                editor.document.textEditorModel.applyEdits(editOperations);
+            }
+        })));
         this.toDispose.push(modelService.onModelDirtyChanged(m => {
             this.proxy.$acceptDirtyStateChanged(m.textEditorModel.uri, m.dirty);
         }));

package/src/main/browser/main-context.ts

@@ -66,6 +66,7 @@ import { NotebooksAndEditorsMain } from './notebooks/notebook-documents-and-edit
 import { TestingMainImpl } from './test-main';
 import { UriMainImpl } from './uri-main';
 import { LoggerMainImpl } from './logger-main';
+import { MonacoEditorProvider } from '@theia/monaco/lib/browser/monaco-editor-provider';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const loggerMain = new LoggerMainImpl(container);
@@ -105,8 +106,9 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const shell = container.get(ApplicationShell);
     const untitledResourceResolver = container.get(UntitledResourceResolver);
     const languageService = container.get(MonacoLanguages);
+    const monacoEditorProvider = container.get(MonacoEditorProvider);
     const documentsMain = new DocumentsMainImpl(editorsAndDocuments, notebookDocumentsMain, modelService, rpc,
-        openerService, shell, untitledResourceResolver, languageService);
+        openerService, shell, untitledResourceResolver, languageService, monacoEditorProvider);
     rpc.set(PLUGIN_RPC_CONTEXT.DOCUMENTS_MAIN, documentsMain);
 
     rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOKS_MAIN, new NotebooksMainImpl(rpc, container, commandRegistryMain));

package/src/main/browser/menus/menus-contribution-handler.ts

@@ -17,18 +17,17 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { inject, injectable, optional } from '@theia/core/shared/inversify';
-import { MenuPath, CommandRegistry, Disposable, DisposableCollection, ActionMenuNode, MenuCommandAdapterRegistry, Emitter, nls } from '@theia/core';
+import { MenuPath, CommandRegistry, Disposable, DisposableCollection, nls, CommandMenu, AcceleratorSource, ContextExpressionMatcher } from '@theia/core';
 import { MenuModelRegistry } from '@theia/core/lib/common';
 import { TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
 import { DeployedPlugin, IconUrl, Menu } from '../../../common';
 import { ScmWidget } from '@theia/scm/lib/browser/scm-widget';
-import { QuickCommandService } from '@theia/core/lib/browser';
+import { KeybindingRegistry, QuickCommandService } from '@theia/core/lib/browser';
 import {
     CodeEditorWidgetUtil, codeToTheiaMappings, ContributionPoint,
     PLUGIN_EDITOR_TITLE_MENU, PLUGIN_EDITOR_TITLE_RUN_MENU, PLUGIN_SCM_TITLE_MENU, PLUGIN_VIEW_TITLE_MENU
 } from './vscode-theia-menu-mappings';
-import { PluginMenuCommandAdapter, ReferenceCountingSet } from './plugin-menu-command-adapter';
-import { ContextKeyExpr } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
+import { PluginMenuCommandAdapter } from './plugin-menu-command-adapter';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { PluginSharedStyle } from '../plugin-shared-style';
 import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
@@ -37,40 +36,35 @@ import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themable
 export class MenusContributionPointHandler {
 
     @inject(MenuModelRegistry) private readonly menuRegistry: MenuModelRegistry;
-    @inject(CommandRegistry) private readonly commands: CommandRegistry;
+    @inject(CommandRegistry) private readonly commandRegistry: CommandRegistry;
     @inject(TabBarToolbarRegistry) private readonly tabBarToolbar: TabBarToolbarRegistry;
-    @inject(CodeEditorWidgetUtil) private readonly codeEditorWidgetUtil: CodeEditorWidgetUtil;
-    @inject(PluginMenuCommandAdapter) protected readonly commandAdapter: PluginMenuCommandAdapter;
-    @inject(MenuCommandAdapterRegistry) protected readonly commandAdapterRegistry: MenuCommandAdapterRegistry;
+    @inject(PluginMenuCommandAdapter) pluginMenuCommandAdapter: PluginMenuCommandAdapter;
     @inject(ContextKeyService) protected readonly contextKeyService: ContextKeyService;
     @inject(PluginSharedStyle) protected readonly style: PluginSharedStyle;
+    @inject(KeybindingRegistry) keybindingRegistry: KeybindingRegistry;
+
     @inject(QuickCommandService) @optional()
     private readonly quickCommandService: QuickCommandService;
 
-    protected readonly titleContributionContextKeys = new ReferenceCountingSet();
-    protected readonly onDidChangeTitleContributionEmitter = new Emitter<void>();
-
     private initialized = false;
     private initialize(): void {
         this.initialized = true;
-        this.commandAdapterRegistry.registerAdapter(this.commandAdapter);
-        this.tabBarToolbar.registerMenuDelegate(PLUGIN_EDITOR_TITLE_MENU, widget => this.codeEditorWidgetUtil.is(widget));
+        this.tabBarToolbar.registerMenuDelegate(PLUGIN_EDITOR_TITLE_MENU, widget => CodeEditorWidgetUtil.is(widget));
+        this.menuRegistry.registerSubmenu(PLUGIN_EDITOR_TITLE_RUN_MENU, 'EditorTitleRunMenu');
         this.tabBarToolbar.registerItem({
-            id: this.tabBarToolbar.toElementId(PLUGIN_EDITOR_TITLE_RUN_MENU), menuPath: PLUGIN_EDITOR_TITLE_RUN_MENU,
-            icon: 'debug-alt', text: nls.localizeByDefault('Run or Debug...'),
-            command: '', group: 'navigation', isVisible: widget => this.codeEditorWidgetUtil.is(widget)
+            id: this.tabBarToolbar.toElementId(PLUGIN_EDITOR_TITLE_RUN_MENU),
+            menuPath: PLUGIN_EDITOR_TITLE_RUN_MENU,
+            icon: 'debug-alt',
+            text: nls.localizeByDefault('Run or Debug...'),
+            command: '',
+            group: 'navigation',
+            isVisible: widget => CodeEditorWidgetUtil.is(widget)
         });
         this.tabBarToolbar.registerMenuDelegate(PLUGIN_SCM_TITLE_MENU, widget => widget instanceof ScmWidget);
-        this.tabBarToolbar.registerMenuDelegate(PLUGIN_VIEW_TITLE_MENU, widget => !this.codeEditorWidgetUtil.is(widget));
-        this.tabBarToolbar.registerItem({ id: 'plugin-menu-contribution-title-contribution', command: '_never_', onDidChange: this.onDidChangeTitleContributionEmitter.event });
-        this.contextKeyService.onDidChange(event => {
-            if (event.affects(this.titleContributionContextKeys)) {
-                this.onDidChangeTitleContributionEmitter.fire();
-            }
-        });
+        this.tabBarToolbar.registerMenuDelegate(PLUGIN_VIEW_TITLE_MENU, widget => !CodeEditorWidgetUtil.is(widget));
     }
 
-    private getMatchingMenu(contributionPoint: ContributionPoint): MenuPath[] | undefined {
+    private getMatchingTheiaMenuPaths(contributionPoint: string): MenuPath[] | undefined {
         return codeToTheiaMappings.get(contributionPoint);
     }
 
@@ -86,7 +80,7 @@ export class MenusContributionPointHandler {
         const submenus = plugin.contributes?.submenus ?? [];
         for (const submenu of submenus) {
             const iconClass = submenu.icon && this.toIconClass(submenu.icon, toDispose);
-            this.menuRegistry.registerIndependentSubmenu(submenu.id, submenu.label, iconClass ? { iconClass } : undefined);
+            this.menuRegistry.registerSubmenu([submenu.id], submenu.label, { icon: iconClass });
         }
 
         for (const [contributionPoint, items] of Object.entries(allMenus)) {
@@ -95,8 +89,10 @@ export class MenusContributionPointHandler {
                     if (contributionPoint === 'commandPalette') {
                         toDispose.push(this.registerCommandPaletteAction(item));
                     } else {
-                        this.checkTitleContribution(contributionPoint, item, toDispose);
-                        const targets = this.getMatchingMenu(contributionPoint as ContributionPoint) ?? [contributionPoint];
+                        let targets = this.getMatchingTheiaMenuPaths(contributionPoint as ContributionPoint);
+                        if (!targets) {
+                            targets = [[contributionPoint]];
+                        }
                         const { group, order } = this.parseGroup(item.group);
                         const { submenu, command } = item;
                         if (submenu && command) {
@@ -105,19 +101,55 @@ export class MenusContributionPointHandler {
                             );
                         }
                         if (command) {
-                            toDispose.push(this.commandAdapter.addCommand(command));
+
                             targets.forEach(target => {
+                                const menuPath = group ? [...target, group] : target;
 
-                                const node = new ActionMenuNode({
-                                    commandId: command,
-                                    when: item.when,
-                                    order
-                                }, this.commands);
-                                const parent = this.menuRegistry.getMenuNode(target, group);
-                                toDispose.push(parent.addNode(node));
+                                const cmd = this.commandRegistry.getCommand(command);
+                                if (!cmd) {
+                                    console.debug(`No label for action menu node: No command "${command}" exists.`);
+                                    return;
+                                }
+                                const label = cmd.label || cmd.id;
+                                const icon = cmd.iconClass;
+                                const action: CommandMenu & AcceleratorSource = {
+                                    id: command,
+                                    sortString: order || '',
+                                    isVisible: <T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: any[]): boolean => {
+                                        if (item.when && !contextMatcher.match(item.when, context)) {
+                                            return false;
+                                        }
+
+                                        return this.commandRegistry.isVisible(command, ...this.pluginMenuCommandAdapter.getArgumentAdapter(contributionPoint)(...args));
+                                    },
+                                    icon: icon,
+                                    label: label,
+                                    isEnabled: (effeciveMenuPath: MenuPath, ...args: any[]): boolean =>
+                                        this.commandRegistry.isEnabled(command, ...this.pluginMenuCommandAdapter.getArgumentAdapter(contributionPoint)(...args)),
+                                    run: (effeciveMenuPath: MenuPath, ...args: any[]): Promise<void> =>
+                                        this.commandRegistry.executeCommand(command, ...this.pluginMenuCommandAdapter.getArgumentAdapter(contributionPoint)(...args)),
+                                    isToggled: (effectiveMenuPath: MenuPath) => false,
+                                    getAccelerator: (context: HTMLElement | undefined): string[] => {
+                                        const bindings = this.keybindingRegistry.getKeybindingsForCommand(command);
+                                        // Only consider the first active keybinding.
+                                        if (bindings.length) {
+                                            const binding = bindings.find(b => this.keybindingRegistry.isEnabledInScope(b, context));
+                                            if (binding) {
+                                                return this.keybindingRegistry.acceleratorFor(binding, '+', true);
+                                            }
+                                        }
+                                        return [];
+                                    }
+                                };
+                                toDispose.push(this.menuRegistry.registerCommandMenu(menuPath, action));
                             });
                         } else if (submenu) {
-                            targets.forEach(target => toDispose.push(this.menuRegistry.linkSubmenu(target, submenu!, { order, when: item.when }, group)));
+                            targets.forEach(target => toDispose.push(this.menuRegistry.linkCompoundMenuNode({
+                                newParentPath: group ? [...target, group] : target,
+                                submenuPath: [submenu!],
+                                order: order,
+                                when: item.when
+                            })));
                         }
                     }
                 } catch (error) {
@@ -146,19 +178,6 @@ export class MenusContributionPointHandler {
         return Disposable.NULL;
     }
 
-    protected checkTitleContribution(contributionPoint: ContributionPoint | string, contribution: { when?: string }, toDispose: DisposableCollection): void {
-        if (contribution.when && contributionPoint.endsWith('title')) {
-            const expression = ContextKeyExpr.deserialize(contribution.when);
-            if (expression) {
-                for (const key of expression.keys()) {
-                    this.titleContributionContextKeys.add(key);
-                    toDispose.push(Disposable.create(() => this.titleContributionContextKeys.delete(key)));
-                }
-                toDispose.push(Disposable.create(() => this.onDidChangeTitleContributionEmitter.fire()));
-            }
-        }
-    }
-
     protected toIconClass(url: IconUrl, toDispose: DisposableCollection): string | undefined {
         if (typeof url === 'string') {
             const asThemeIcon = ThemeIcon.fromString(url);

package/src/main/browser/menus/plugin-menu-command-adapter.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { CommandRegistry, Disposable, MenuCommandAdapter, MenuPath, SelectionService, UriSelection } from '@theia/core';
+import { SelectionService, UriSelection } from '@theia/core';
 import { ResourceContextKey } from '@theia/core/lib/browser/resource-context-key';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
@@ -29,57 +29,20 @@ import { ScmCommandArg, TimelineCommandArg, TreeViewItemReference } from '../../
 import { TestItemReference, TestMessageArg } from '../../../common/test-types';
 import { PluginScmProvider, PluginScmResource, PluginScmResourceGroup } from '../scm-main';
 import { TreeViewWidget } from '../view/tree-view-widget';
-import { CodeEditorWidgetUtil, codeToTheiaMappings, ContributionPoint } from './vscode-theia-menu-mappings';
-import { TAB_BAR_TOOLBAR_CONTEXT_MENU } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+import { CodeEditorWidgetUtil, ContributionPoint } from './vscode-theia-menu-mappings';
 import { TestItem, TestMessage } from '@theia/test/lib/browser/test-service';
 
 export type ArgumentAdapter = (...args: unknown[]) => unknown[];
-
-export class ReferenceCountingSet<T> {
-    protected readonly references: Map<T, number>;
-    constructor(initialMembers?: Iterable<T>) {
-        this.references = new Map();
-        if (initialMembers) {
-            for (const member of initialMembers) {
-                this.add(member);
-            }
-        }
-    }
-
-    add(newMember: T): ReferenceCountingSet<T> {
-        const value = this.references.get(newMember) ?? 0;
-        this.references.set(newMember, value + 1);
-        return this;
-    }
-
-    /** @returns true if the deletion results in the removal of the element from the set */
-    delete(member: T): boolean {
-        const value = this.references.get(member);
-        if (value === undefined) { } else if (value <= 1) {
-            this.references.delete(member);
-            return true;
-        } else {
-            this.references.set(member, value - 1);
-        }
-        return false;
-    }
-
-    has(maybeMember: T): boolean {
-        return this.references.has(maybeMember);
-    }
+function identity(...args: unknown[]): unknown[] {
+    return args;
 }
-
 @injectable()
-export class PluginMenuCommandAdapter implements MenuCommandAdapter {
-    @inject(CommandRegistry) protected readonly commandRegistry: CommandRegistry;
-    @inject(CodeEditorWidgetUtil) protected readonly codeEditorUtil: CodeEditorWidgetUtil;
-    @inject(ScmService) protected readonly scmService: ScmService;
-    @inject(SelectionService) protected readonly selectionService: SelectionService;
-    @inject(ResourceContextKey) protected readonly resourceContextKey: ResourceContextKey;
+export class PluginMenuCommandAdapter {
+    @inject(ScmService) private readonly scmService: ScmService;
+    @inject(SelectionService) private readonly selectionService: SelectionService;
+    @inject(ResourceContextKey) private readonly resourceContextKey: ResourceContextKey;
 
-    protected readonly commands = new ReferenceCountingSet<string>();
     protected readonly argumentAdapters = new Map<string, ArgumentAdapter>();
-    protected readonly separator = ':)(:';
 
     @postConstruct()
     protected init(): void {
@@ -89,8 +52,8 @@ export class PluginMenuCommandAdapter implements MenuCommandAdapter {
         const noArgs: ArgumentAdapter = () => [];
         const toScmArgs: ArgumentAdapter = (...args) => this.toScmArgs(...args);
         const selectedResource = () => this.getSelectedResources();
-        const widgetURI: ArgumentAdapter = widget => this.codeEditorUtil.is(widget) ? [this.codeEditorUtil.getResourceUri(widget)] : [];
-        (<Array<[ContributionPoint, ArgumentAdapter | undefined]>>[
+        const widgetURI: ArgumentAdapter = widget => CodeEditorWidgetUtil.is(widget) ? [CodeEditorWidgetUtil.getResourceUri(widget)] : [];
+        (<Array<[ContributionPoint, ArgumentAdapter]>>[
             ['comments/comment/context', toCommentArgs],
             ['comments/comment/title', toCommentArgs],
             ['comments/commentThread/context', toCommentArgs],
@@ -117,82 +80,12 @@ export class PluginMenuCommandAdapter implements MenuCommandAdapter {
             ['terminal/context', noArgs],
             ['terminal/title/context', noArgs],
         ]).forEach(([contributionPoint, adapter]) => {
-            if (adapter) {
-                const paths = codeToTheiaMappings.get(contributionPoint);
-                if (paths) {
-                    paths.forEach(path => this.addArgumentAdapter(path, adapter));
-                }
-            }
+            this.argumentAdapters.set(contributionPoint, adapter);
         });
-        this.addArgumentAdapter(TAB_BAR_TOOLBAR_CONTEXT_MENU, widgetURI);
-    }
-
-    canHandle(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): number {
-        if (this.commands.has(command) && this.getArgumentAdapterForMenu(menuPath)) {
-            return 500;
-        }
-        return -1;
-    }
-
-    executeCommand(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): Promise<unknown> {
-        const argumentAdapter = this.getAdapterOrThrow(menuPath);
-        return this.commandRegistry.executeCommand(command, ...argumentAdapter(...commandArgs));
-    }
-
-    isVisible(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
-        const argumentAdapter = this.getAdapterOrThrow(menuPath);
-        return this.commandRegistry.isVisible(command, ...argumentAdapter(...commandArgs));
-    }
-
-    isEnabled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
-        const argumentAdapter = this.getAdapterOrThrow(menuPath);
-        return this.commandRegistry.isEnabled(command, ...argumentAdapter(...commandArgs));
-    }
-
-    isToggled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
-        const argumentAdapter = this.getAdapterOrThrow(menuPath);
-        return this.commandRegistry.isToggled(command, ...argumentAdapter(...commandArgs));
-    }
-
-    protected getAdapterOrThrow(menuPath: MenuPath): ArgumentAdapter {
-        const argumentAdapter = this.getArgumentAdapterForMenu(menuPath);
-        if (!argumentAdapter) {
-            throw new Error('PluginMenuCommandAdapter attempted to execute command for unregistered menu: ' + JSON.stringify(menuPath));
-        }
-        return argumentAdapter;
-    }
-
-    addCommand(commandId: string): Disposable {
-        this.commands.add(commandId);
-        return Disposable.create(() => this.commands.delete(commandId));
-    }
-
-    protected getArgumentAdapterForMenu(menuPath: MenuPath): ArgumentAdapter | undefined {
-        let result;
-        let length = 0;
-        for (const [key, value] of this.argumentAdapters.entries()) {
-            const candidate = key.split(this.separator);
-            if (this.isPrefixOf(candidate, menuPath) && candidate.length > length) {
-                result = value;
-                length = candidate.length;
-            }
-        }
-        return result;
-    }
-    isPrefixOf(candidate: string[], menuPath: MenuPath): boolean {
-        if (candidate.length > menuPath.length) {
-            return false;
-        }
-        for (let i = 0; i < candidate.length; i++) {
-            if (candidate[i] !== menuPath[i]) {
-                return false;
-            }
-        }
-        return true;
     }
 
-    protected addArgumentAdapter(menuPath: MenuPath, adapter: ArgumentAdapter): void {
-        this.argumentAdapters.set(menuPath.join(this.separator), adapter);
+    getArgumentAdapter(contributionPoint: string): ArgumentAdapter {
+        return this.argumentAdapters.get(contributionPoint) || identity;
     }
 
     /* eslint-disable @typescript-eslint/no-explicit-any */

package/src/main/browser/menus/vscode-theia-menu-mappings.ts

@@ -17,7 +17,6 @@
 import { MenuPath } from '@theia/core';
 import { SHELL_TABBAR_CONTEXT_MENU } from '@theia/core/lib/browser';
 import { Navigatable } from '@theia/core/lib/browser/navigatable';
-import { injectable } from '@theia/core/shared/inversify';
 import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
 import { DebugStackFramesWidget } from '@theia/debug/lib/browser/view/debug-stack-frames-widget';
 import { DebugThreadsWidget } from '@theia/debug/lib/browser/view/debug-threads-widget';
@@ -74,7 +73,7 @@ export const implementedVSCodeContributionPoints = [
 export type ContributionPoint = (typeof implementedVSCodeContributionPoints)[number];
 
 /** The values are menu paths to which the VSCode contribution points correspond */
-export const codeToTheiaMappings = new Map<ContributionPoint, MenuPath[]>([
+export const codeToTheiaMappings = new Map<string, MenuPath[]>([
     ['comments/comment/context', [COMMENT_CONTEXT]],
     ['comments/comment/title', [COMMENT_TITLE]],
     ['comments/commentThread/context', [COMMENT_THREAD_CONTEXT]],
@@ -106,12 +105,11 @@ export const codeToTheiaMappings = new Map<ContributionPoint, MenuPath[]>([
 ]);
 
 type CodeEditorWidget = EditorWidget | WebviewWidget;
-@injectable()
-export class CodeEditorWidgetUtil {
-    is(arg: unknown): arg is CodeEditorWidget {
+export namespace CodeEditorWidgetUtil {
+    export function is(arg: unknown): arg is CodeEditorWidget {
         return arg instanceof EditorWidget || arg instanceof WebviewWidget;
     }
-    getResourceUri(editor: CodeEditorWidget): CodeUri | undefined {
+    export function getResourceUri(editor: CodeEditorWidget): CodeUri | undefined {
         const resourceUri = Navigatable.is(editor) && editor.getResourceUri();
         return resourceUri ? resourceUri['codeUri'] : undefined;
     }

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -68,7 +68,7 @@ import { WebviewWidgetFactory } from './webview/webview-widget-factory';
 import { CommentsService, PluginCommentService } from './comments/comments-service';
 import { CommentingRangeDecorator } from './comments/comments-decorator';
 import { CommentsContribution } from './comments/comments-contribution';
-import { CommentsContextKeyService } from './comments/comments-context-key-service';
+import { CommentsContext } from './comments/comments-context';
 import { PluginCustomEditorRegistry } from './custom-editors/plugin-custom-editor-registry';
 import { CustomEditorWidgetFactory } from '../browser/custom-editors/custom-editor-widget-factory';
 import { CustomEditorWidget } from './custom-editors/custom-editor-widget';
@@ -77,7 +77,6 @@ import { WebviewFrontendSecurityWarnings } from './webview/webview-frontend-secu
 import { PluginAuthenticationServiceImpl } from './plugin-authentication-service';
 import { AuthenticationService } from '@theia/core/lib/browser/authentication-service';
 import { bindTreeViewDecoratorUtilities, TreeViewDecoratorService } from './view/tree-view-decorator-service';
-import { CodeEditorWidgetUtil } from './menus/vscode-theia-menu-mappings';
 import { PluginMenuCommandAdapter } from './menus/plugin-menu-command-adapter';
 import './theme-icon-override';
 import { PluginIconService } from './plugin-icon-service';
@@ -250,7 +249,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     bind(MenusContributionPointHandler).toSelf().inSingletonScope();
     bind(PluginMenuCommandAdapter).toSelf().inSingletonScope();
-    bind(CodeEditorWidgetUtil).toSelf().inSingletonScope();
     bind(KeybindingsContributionPointHandler).toSelf().inSingletonScope();
     bind(PluginContributionHandler).toSelf().inSingletonScope();
 
@@ -266,7 +264,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(CommentsService).to(PluginCommentService).inSingletonScope();
     bind(CommentingRangeDecorator).toSelf().inSingletonScope();
     bind(CommentsContribution).toSelf().inSingletonScope();
-    bind(CommentsContextKeyService).toSelf().inSingletonScope();
+    bind(CommentsContext).toSelf().inSingletonScope();
 
     bind(WebviewFrontendSecurityWarnings).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(WebviewFrontendSecurityWarnings);

package/src/main/browser/style/comments.css

@@ -8,6 +8,7 @@
     margin-left: 5px;
     cursor: pointer;
 }
+
 .comment-range-glyph:before {
     position: absolute;
     content: '';
@@ -36,6 +37,7 @@
     border-left: 3px solid var(--theia-editorGutter-commentRangeForeground);
     transition: opacity 0.5s;
 }
+
 .monaco-editor .comment-diff-added:before {
     background: var(--theia-editorGutter-commentRangeForeground);
 }
@@ -123,6 +125,7 @@
 }
 
 .monaco-editor .review-widget .body .review-comment .avatar-container {
+    margin-right: 8px !important;
     margin-top: 4px !important;
 }
 
@@ -138,7 +141,6 @@
 }
 
 .monaco-editor .review-widget .body .review-comment .review-comment-contents {
-    padding-left: 20px;
     user-select: text;
     -webkit-user-select: text;
     width: 100%;
@@ -255,6 +257,12 @@
     max-width: 100%;
 }
 
+.monaco-editor .review-widget .body .comment-form {
+    flex: 1;
+    margin: 0px;
+    /* Reset margin as it's handled by container */
+}
+
 .monaco-editor .review-widget .body .comment-form .form-actions {
     display: none;
 }

package/src/main/browser/terminal-main.ts

@@ -130,9 +130,12 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
         }));
         this.toDispose.push(terminal.onData(data => {
             this.extProxy.$terminalOnInput(terminal.id, data);
-            this.extProxy.$terminalStateChanged(terminal.id);
+            this.extProxy.$terminalOnInteraction(terminal.id);
         }));
 
+        this.toDispose.push(terminal.onShellTypeChanged(shellType => {
+            this.extProxy.$terminalShellTypeChanged(terminal.id, shellType);
+        }));
         this.observers.forEach((observer, id) => this.observeTerminal(id, terminal, observer));
     }
 

package/src/main/browser/text-editor-model-service.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { Event, Emitter } from '@theia/core';
-import { MonacoEditorModel, WillSaveMonacoModelEvent } from '@theia/monaco/lib/browser/monaco-editor-model';
+import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { MonacoTextModelService } from '@theia/monaco/lib/browser/monaco-text-model-service';
 import { MonacoWorkspace } from '@theia/monaco/lib/browser/monaco-workspace';
@@ -30,13 +30,11 @@ export class EditorModelService {
     private onModelRemovedEmitter = new Emitter<MonacoEditorModel>();
     private modelDirtyEmitter = new Emitter<MonacoEditorModel>();
     private modelSavedEmitter = new Emitter<MonacoEditorModel>();
-    private onModelWillSavedEmitter = new Emitter<WillSaveMonacoModelEvent>();
 
     readonly onModelDirtyChanged = this.modelDirtyEmitter.event;
     readonly onModelSaved = this.modelSavedEmitter.event;
     readonly onModelModeChanged = this.modelModeChangedEmitter.event;
     readonly onModelRemoved = this.onModelRemovedEmitter.event;
-    readonly onModelWillSave = this.onModelWillSavedEmitter.event;
 
     constructor(@inject(MonacoTextModelService) monacoModelService: MonacoTextModelService,
         @inject(MonacoWorkspace) monacoWorkspace: MonacoWorkspace) {
@@ -63,9 +61,6 @@ export class EditorModelService {
         model.onDirtyChanged(_ => {
             this.modelDirtyEmitter.fire(model);
         });
-        model.onWillSaveModel(willSaveModelEvent => {
-            this.onModelWillSavedEmitter.fire(willSaveModelEvent);
-        });
     }
 
     get onModelAdded(): Event<MonacoEditorModel> {