@theia/core 1.62.0-next.3 → 1.62.1

package/src/browser/menu/browser-menu-plugin.ts

@@ -18,8 +18,8 @@ import { injectable, inject } from 'inversify';
 import { Menu, MenuBar, Menu as MenuWidget, Widget } from '@lumino/widgets';
 import { CommandRegistry as LuminoCommandRegistry } from '@lumino/commands';
 import {
-    CommandRegistry, environment, DisposableCollection, Disposable,
-    MenuModelRegistry, MAIN_MENU_BAR, MenuPath, MenuNode, MenuCommandExecutor, CompoundMenuNode, CompoundMenuNodeRole, CommandMenuNode,
+    environment, DisposableCollection,
+    AcceleratorSource,
     ArrayUtils
 } from '../../common';
 import { KeybindingRegistry } from '../keybinding';
@@ -32,6 +32,8 @@ import { ApplicationShell } from '../shell';
 import { CorePreferences } from '../core-preferences';
 import { PreferenceService } from '../preferences/preference-service';
 import { ElementExt } from '@lumino/domutils';
+import { CommandMenu, CompoundMenuNode, MAIN_MENU_BAR, MenuNode, MenuPath, RenderedMenuNode, Submenu } from '../../common/menu/menu-types';
+import { MenuModelRegistry } from '../../common/menu/menu-model-registry';
 
 export abstract class MenuBarWidget extends MenuBar {
     abstract activateMenu(label: string, ...labels: string[]): Promise<MenuWidget>;
@@ -39,10 +41,7 @@ export abstract class MenuBarWidget extends MenuBar {
 }
 
 export interface BrowserMenuOptions extends MenuWidget.IOptions {
-    commands: MenuCommandRegistry,
     context?: HTMLElement,
-    contextKeyService?: ContextMatcher;
-    rootMenuPath: MenuPath
 };
 
 @injectable()
@@ -54,12 +53,6 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
     @inject(ContextMenuContext)
     protected readonly context: ContextMenuContext;
 
-    @inject(CommandRegistry)
-    protected readonly commandRegistry: CommandRegistry;
-
-    @inject(MenuCommandExecutor)
-    protected readonly menuCommandExecutor: MenuCommandExecutor;
-
     @inject(CorePreferences)
     protected readonly corePreferences: CorePreferences;
 
@@ -108,53 +101,31 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
     }
 
     protected fillMenuBar(menuBar: MenuBarWidget): void {
-        const menuModel = this.menuProvider.getMenu(MAIN_MENU_BAR);
-        const menuCommandRegistry = this.createMenuCommandRegistry(menuModel);
+        const menuModel = this.menuProvider.getMenuNode(MAIN_MENU_BAR) as Submenu;
+        const menuCommandRegistry = new LuminoCommandRegistry();
         for (const menu of menuModel.children) {
-            if (CompoundMenuNode.is(menu)) {
-                const menuWidget = this.createMenuWidget(menu, { commands: menuCommandRegistry, rootMenuPath: MAIN_MENU_BAR });
+            if (CompoundMenuNode.is(menu) && RenderedMenuNode.is(menu)) {
+                const menuWidget = this.createMenuWidget(MAIN_MENU_BAR, menu, this.contextKeyService, { commands: menuCommandRegistry });
                 menuBar.addMenu(menuWidget);
             }
         }
     }
 
-    createContextMenu(path: MenuPath, args?: unknown[], context?: HTMLElement, contextKeyService?: ContextMatcher, skipSingleRootNode?: boolean): MenuWidget {
-        const menuModel = skipSingleRootNode ? this.menuProvider.removeSingleRootNode(this.menuProvider.getMenu(path), path) : this.menuProvider.getMenu(path);
-        const menuCommandRegistry = this.createMenuCommandRegistry(menuModel, args).snapshot(path);
-        const contextMenu = this.createMenuWidget(menuModel, { commands: menuCommandRegistry, context, rootMenuPath: path, contextKeyService });
+    createContextMenu(effectiveMenuPath: MenuPath, menuModel: CompoundMenuNode, contextMatcher: ContextMatcher, args?: unknown[], context?: HTMLElement): MenuWidget {
+        const menuCommandRegistry = new LuminoCommandRegistry();
+        const contextMenu = this.createMenuWidget(effectiveMenuPath, menuModel, contextMatcher, { commands: menuCommandRegistry, context }, args);
         return contextMenu;
     }
 
-    createMenuWidget(menu: CompoundMenuNode, options: BrowserMenuOptions): DynamicMenuWidget {
-        return new DynamicMenuWidget(menu, options, this.services);
-    }
-
-    protected createMenuCommandRegistry(menu: CompoundMenuNode, args: unknown[] = []): MenuCommandRegistry {
-        const menuCommandRegistry = new MenuCommandRegistry(this.services);
-        this.registerMenu(menuCommandRegistry, menu, args);
-        return menuCommandRegistry;
-    }
-
-    protected registerMenu(menuCommandRegistry: MenuCommandRegistry, menu: MenuNode, args: unknown[]): void {
-        if (CompoundMenuNode.is(menu)) {
-            menu.children.forEach(child => this.registerMenu(menuCommandRegistry, child, args));
-        } else if (CommandMenuNode.is(menu)) {
-            menuCommandRegistry.registerActionMenu(menu, args);
-            if (CommandMenuNode.hasAltHandler(menu)) {
-                menuCommandRegistry.registerActionMenu(menu.altNode, args);
-            }
-
-        }
+    createMenuWidget(parentPath: MenuPath, menu: CompoundMenuNode, contextMatcher: ContextMatcher, options: BrowserMenuOptions, args?: unknown[]): DynamicMenuWidget {
+        return new DynamicMenuWidget(parentPath, menu, options, contextMatcher, this.services, args);
     }
 
     protected get services(): MenuServices {
         return {
-            context: this.context,
             contextKeyService: this.contextKeyService,
-            commandRegistry: this.commandRegistry,
-            keybindingRegistry: this.keybindingRegistry,
+            context: this.context,
             menuWidgetFactory: this,
-            commandExecutor: this.menuCommandExecutor,
         };
     }
 
@@ -235,41 +206,43 @@ export class DynamicMenuBarWidget extends MenuBarWidget {
 }
 
 export class MenuServices {
-    readonly commandRegistry: CommandRegistry;
-    readonly keybindingRegistry: KeybindingRegistry;
     readonly contextKeyService: ContextKeyService;
     readonly context: ContextMenuContext;
     readonly menuWidgetFactory: MenuWidgetFactory;
-    readonly commandExecutor: MenuCommandExecutor;
 }
 
 export interface MenuWidgetFactory {
-    createMenuWidget(menu: MenuNode & Required<Pick<MenuNode, 'children'>>, options: BrowserMenuOptions): MenuWidget;
+    createMenuWidget(effectiveMenuPath: MenuPath, menu: Submenu, contextMatcher: ContextMatcher, options: BrowserMenuOptions): MenuWidget;
 }
 
 /**
  * A menu widget that would recompute its items on update.
  */
 export class DynamicMenuWidget extends MenuWidget {
-
+    private static nextCommmandId = 0;
     /**
      * We want to restore the focus after the menu closes.
      */
     protected previousFocusedElement: HTMLElement | undefined;
 
     constructor(
+        protected readonly effectiveMenuPath: MenuPath,
         protected menu: CompoundMenuNode,
         protected options: BrowserMenuOptions,
-        protected services: MenuServices
+        protected contextMatcher: ContextMatcher,
+        protected services: MenuServices,
+        protected args?: unknown[]
     ) {
         super(options);
-        if (menu.label) {
-            this.title.label = menu.label;
-        }
-        if (menu.icon) {
-            this.title.iconClass = menu.icon;
+        if (RenderedMenuNode.is(this.menu)) {
+            if (this.menu.label) {
+                this.title.label = this.menu.label;
+            }
+            if (this.menu.icon) {
+                this.title.iconClass = this.menu.icon;
+            }
         }
-        this.updateSubMenus(this, this.menu, this.options.commands);
+        this.updateSubMenus(this.effectiveMenuPath, this, this.menu, this.options.commands, this.contextMatcher, this.options.context);
     }
 
     protected override onAfterAttach(msg: Message): void {
@@ -318,8 +291,7 @@ export class DynamicMenuWidget extends MenuWidget {
         this.preserveFocusedElement(previousFocusedElement);
         this.clearItems();
         this.runWithPreservedFocusContext(() => {
-            this.options.commands.snapshot(this.options.rootMenuPath);
-            this.updateSubMenus(this, this.menu, this.options.commands);
+            this.updateSubMenus(this.effectiveMenuPath, this, this.menu, this.options.commands, this.contextMatcher, this.options.context);
         });
     }
 
@@ -333,8 +305,9 @@ export class DynamicMenuWidget extends MenuWidget {
         super.open(x, y, options);
     }
 
-    protected updateSubMenus(parent: MenuWidget, menu: CompoundMenuNode, commands: MenuCommandRegistry): void {
-        const items = this.buildSubMenus([], menu, commands);
+    protected updateSubMenus(parentPath: MenuPath, parent: MenuWidget, menu: CompoundMenuNode, commands: LuminoCommandRegistry,
+        contextMatcher: ContextMatcher, context?: HTMLElement | undefined): void {
+        const items = this.createItems(parentPath, menu.children, commands, contextMatcher, context);
         while (items[items.length - 1]?.type === 'separator') {
             items.pop();
         }
@@ -350,43 +323,58 @@ export class DynamicMenuWidget extends MenuWidget {
         }
     }
 
-    protected buildSubMenus(parentItems: MenuWidget.IItemOptions[], menu: MenuNode, commands: MenuCommandRegistry): MenuWidget.IItemOptions[] {
-        if (CompoundMenuNode.is(menu)
-            && menu.children.length
-            && this.undefinedOrMatch(this.options.contextKeyService ?? this.services.contextKeyService, menu.when, this.options.context)) {
-            const role = menu === this.menu ? CompoundMenuNodeRole.Group : CompoundMenuNode.getRole(menu);
-            if (role === CompoundMenuNodeRole.Submenu) {
-                const submenu = this.services.menuWidgetFactory.createMenuWidget(menu, this.options);
-                if (submenu.items.length > 0) {
-                    parentItems.push({ type: 'submenu', submenu });
-                }
-            } else if (role === CompoundMenuNodeRole.Group && menu.id !== 'inline') {
-                const children = CompoundMenuNode.getFlatChildren(menu.children);
-                const myItems: MenuWidget.IItemOptions[] = [];
-                children.forEach(child => this.buildSubMenus(myItems, child, commands));
-                if (myItems.length) {
-                    if (parentItems.length && parentItems[parentItems.length - 1].type !== 'separator') {
-                        parentItems.push({ type: 'separator' });
+    protected createItems(parentPath: MenuPath, nodes: MenuNode[], phCommandRegistry: LuminoCommandRegistry,
+        contextMatcher: ContextMatcher, context?: HTMLElement): MenuWidget.IItemOptions[] {
+        const result: MenuWidget.IItemOptions[] = [];
+
+        for (const node of nodes) {
+            const nodePath = [...parentPath, node.id];
+            if (node.isVisible(nodePath, contextMatcher, context, ...(this.args || []))) {
+                if (CompoundMenuNode.is(node)) {
+                    if (RenderedMenuNode.is(node)) {
+                        const submenu = this.services.menuWidgetFactory.createMenuWidget(nodePath, node, this.contextMatcher, this.options);
+                        if (submenu.items.length > 0) {
+                            result.push({ type: 'submenu', submenu });
+                        }
+                    } else {
+                        const items = this.createItems(nodePath, node.children, phCommandRegistry, contextMatcher, context);
+                        if (items.length > 0) {
+                            if (node.id !== 'inline') {
+                                result.push({ type: 'separator' });
+                            }
+                            result.push(...items);
+                            if (node.id !== 'inline') {
+                                result.push({ type: 'separator' });
+                            }
+                        }
+                    }
+                } else if (CommandMenu.is(node)) {
+                    const id = !phCommandRegistry.hasCommand(node.id) ? node.id : `${node.id}:${DynamicMenuWidget.nextCommmandId++}`;
+                    phCommandRegistry.addCommand(id, {
+                        execute: () => { node.run(nodePath, ...(this.args || [])); },
+                        isEnabled: () => node.isEnabled(nodePath, ...(this.args || [])),
+                        isToggled: () => node.isToggled ? !!node.isToggled(nodePath, ...(this.args || [])) : false,
+                        isVisible: () => true,
+                        label: node.label,
+                        iconClass: node.icon,
+                    });
+
+                    const accelerator = (AcceleratorSource.is(node) ? node.getAccelerator(this.options.context) : []);
+                    if (accelerator.length > 0) {
+                        phCommandRegistry.addKeyBinding({
+                            command: id,
+                            keys: accelerator,
+                            selector: '.p-Widget' // We have the PhosphorJS dependency anyway.
+                        });
                     }
-                    parentItems.push(...myItems);
-                    parentItems.push({ type: 'separator' });
+                    result.push({
+                        command: id,
+                        type: 'command'
+                    });
                 }
             }
-        } else if (menu.command) {
-            const node = menu.altNode && this.services.context.altPressed ? menu.altNode : (menu as MenuNode & CommandMenuNode);
-            if (commands.isVisible(node.command) && this.undefinedOrMatch(this.options.contextKeyService ?? this.services.contextKeyService, node.when, this.options.context)) {
-                parentItems.push({
-                    command: node.command,
-                    type: 'command'
-                });
-            }
         }
-        return parentItems;
-    }
-
-    protected undefinedOrMatch(contextKeyService: ContextMatcher, expression?: string, context?: HTMLElement): boolean {
-        if (expression) { return contextKeyService.match(expression, context); }
-        return true;
+        return result;
     }
 
     protected preserveFocusedElement(previousFocusedElement: Element | null = document.activeElement): boolean {
@@ -473,79 +461,3 @@ export class BrowserMenuBarContribution implements FrontendApplicationContributi
         return logo;
     }
 }
-
-/**
- * Stores Theia-specific action menu nodes instead of Lumino commands with their handlers.
- */
-export class MenuCommandRegistry extends LuminoCommandRegistry {
-
-    protected actions = new Map<string, [MenuNode & CommandMenuNode, unknown[]]>();
-    protected toDispose = new DisposableCollection();
-
-    constructor(protected services: MenuServices) {
-        super();
-    }
-
-    registerActionMenu(menu: MenuNode & CommandMenuNode, args: unknown[]): void {
-        const { commandRegistry } = this.services;
-        const command = commandRegistry.getCommand(menu.command);
-        if (!command) {
-            return;
-        }
-        const { id } = command;
-        if (this.actions.has(id)) {
-            return;
-        }
-        this.actions.set(id, [menu, args]);
-    }
-
-    snapshot(menuPath: MenuPath): this {
-        this.toDispose.dispose();
-        for (const [menu, args] of this.actions.values()) {
-            this.toDispose.push(this.registerCommand(menu, args, menuPath));
-        }
-        return this;
-    }
-
-    protected registerCommand(menu: MenuNode & CommandMenuNode, args: unknown[], menuPath: MenuPath): Disposable {
-        const { commandRegistry, keybindingRegistry, commandExecutor } = this.services;
-        const command = commandRegistry.getCommand(menu.command);
-        if (!command) {
-            return Disposable.NULL;
-        }
-        const { id } = command;
-        if (this.hasCommand(id)) {
-            // several menu items can be registered for the same command in different contexts
-            return Disposable.NULL;
-        }
-
-        // We freeze the `isEnabled`, `isVisible`, and `isToggled` states so they won't change.
-        const enabled = commandExecutor.isEnabled(menuPath, id, ...args);
-        const visible = commandExecutor.isVisible(menuPath, id, ...args);
-        const toggled = commandExecutor.isToggled(menuPath, id, ...args);
-        const unregisterCommand = this.addCommand(id, {
-            execute: () => commandExecutor.executeCommand(menuPath, id, ...args),
-            label: menu.label,
-            iconClass: menu.icon,
-            isEnabled: () => enabled,
-            isVisible: () => visible,
-            isToggled: () => toggled
-        });
-
-        const bindings = keybindingRegistry.getKeybindingsForCommand(id);
-        // Only consider the first active keybinding.
-        if (bindings.length) {
-            const binding = bindings.length > 1 ?
-                bindings.find(b => !b.when || this.services.contextKeyService.match(b.when)) ?? bindings[0] :
-                bindings[0];
-            const keys = keybindingRegistry.acceleratorFor(binding, ' ', true);
-            this.addKeyBinding({
-                command: id,
-                keys,
-                selector: '.lm-Widget' // We have the Lumino dependency anyway.
-            });
-        }
-        return Disposable.create(() => unregisterCommand.dispose());
-    }
-
-}

package/src/browser/menu/composite-menu-node.ts

@@ -0,0 +1,140 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 { CompoundMenuNode, ContextExpressionMatcher, Group, MenuNode, MenuPath, Submenu } from '../../common/menu/menu-types';
+import { Event } from '../../common';
+
+export class SubMenuLink implements CompoundMenuNode {
+    constructor(private readonly delegate: Submenu, private readonly _sortString?: string, private readonly _when?: string) { }
+
+    get id(): string { return this.delegate.id; };
+    get onDidChange(): Event<void> | undefined { return this.delegate.onDidChange; };
+    get children(): MenuNode[] { return this.delegate.children; }
+    get contextKeyOverlays(): Record<string, string> | undefined { return this.delegate.contextKeyOverlays; }
+    get label(): string { return this.delegate.label; };
+    get icon(): string | undefined { return this.delegate.icon; };
+
+    get sortString(): string { return this._sortString || this.delegate.sortString; };
+    isVisible<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean {
+        return this.delegate.isVisible(effectiveMenuPath, contextMatcher, context) && this._when ? contextMatcher.match(this._when, context) : true;
+    }
+
+    isEmpty<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean {
+        return this.delegate.isEmpty(effectiveMenuPath, contextMatcher, context, args);
+    }
+}
+
+/**
+ * Node representing a (sub)menu in the menu tree structure.
+ */
+export abstract class AbstractCompoundMenuImpl implements MenuNode {
+    readonly children: MenuNode[] = [];
+
+    protected constructor(
+        readonly id: string,
+        protected readonly orderString?: string,
+        protected readonly when?: string
+    ) {
+    }
+
+    getOrCreate(menuPath: MenuPath, pathIndex: number, endIndex: number): CompoundMenuImpl {
+        if (pathIndex === endIndex) {
+            return this;
+        }
+        let child = this.getNode(menuPath[pathIndex]);
+        if (!child) {
+            child = new GroupImpl(menuPath[pathIndex]);
+            this.addNode(child);
+        }
+        if (child instanceof AbstractCompoundMenuImpl) {
+            return child.getOrCreate(menuPath, pathIndex + 1, endIndex);
+        } else {
+            throw new Error(`An item exists, but it's not a parent: ${menuPath} at ${pathIndex}`);
+        }
+
+    }
+
+    /**
+     * Menu nodes are sorted in ascending order based on their `sortString`.
+     */
+    isVisible<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean {
+        return (!this.when || contextMatcher.match(this.when, context));
+    }
+
+    isEmpty<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean {
+        for (const child of this.children) {
+            if (child.isVisible(effectiveMenuPath, contextMatcher, context, args)) {
+                if (!CompoundMenuNode.is(child) || !child.isEmpty(effectiveMenuPath, contextMatcher, context, args)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    addNode(...node: MenuNode[]): void {
+        this.children.push(...node);
+        this.children.sort(CompoundMenuNode.sortChildren);
+    }
+
+    getNode(id: string): MenuNode | undefined {
+        return this.children.find(node => node.id === id);
+    }
+
+    removeById(id: string): void {
+        const idx = this.children.findIndex(node => node.id === id);
+        if (idx >= 0) {
+            this.children.splice(idx, 1);
+        }
+    }
+
+    removeNode(node: MenuNode): void {
+        const idx = this.children.indexOf(node);
+        if (idx >= 0) {
+            this.children.splice(idx, 1);
+        }
+    }
+
+    get sortString(): string {
+        return this.orderString || this.id;
+    }
+}
+
+export class GroupImpl extends AbstractCompoundMenuImpl implements Group {
+    constructor(
+        id: string,
+        orderString?: string,
+        when?: string
+    ) {
+        super(id, orderString, when);
+    }
+}
+
+export class SubmenuImpl extends AbstractCompoundMenuImpl implements Submenu {
+
+    constructor(
+        id: string,
+        readonly label: string,
+        readonly contextKeyOverlays: Record<string, string> | undefined,
+        orderString?: string,
+        readonly icon?: string,
+        when?: string,
+    ) {
+        super(id, orderString, when);
+    }
+}
+
+export type CompoundMenuImpl = SubmenuImpl | GroupImpl;

package/src/{common → browser}/menu/menu.spec.ts

@@ -15,12 +15,40 @@
 // *****************************************************************************
 
 import * as chai from 'chai';
-import { CommandContribution, CommandRegistry } from '../command';
-import { CompositeMenuNode } from './composite-menu-node';
-import { MenuContribution, MenuModelRegistry } from './menu-model-registry';
+import {
+    CommandContribution, CommandMenu, CommandRegistry, CompoundMenuNode, Group, GroupImpl, MenuAction, MenuContribution,
+    MenuModelRegistry, MenuNode, MenuNodeFactory, MutableCompoundMenuNode, Submenu,
+    SubmenuImpl,
+    SubMenuLink
+} from '../../common';
 
 const expect = chai.expect;
 
+class TestMenuNodeFactory implements MenuNodeFactory {
+    createGroup(id: string, orderString?: string, when?: string): Group & MutableCompoundMenuNode {
+        return new GroupImpl(id, orderString, when);
+    }
+    createSubmenu(id: string, label: string, contextKeyOverlays: Record<string, string> | undefined, orderString?: string, icon?: string, when?: string):
+        Submenu & MutableCompoundMenuNode {
+        return new SubmenuImpl(id, label, contextKeyOverlays, orderString, icon, when);
+    }
+    createSubmenuLink(delegate: Submenu, sortString?: string, when?: string): MenuNode {
+        return new SubMenuLink(delegate, sortString, when);
+    }
+
+    createCommandMenu(item: MenuAction): CommandMenu {
+        return {
+            isVisible: () => true,
+            isEnabled: () => true,
+            isToggled: () => false,
+            id: item.commandId,
+            label: item.label || '',
+            sortString: item.order || '',
+            run: () => Promise.resolve()
+        };
+    }
+}
+
 describe('menu-model-registry', () => {
 
     describe('01 #register', () => {
@@ -49,15 +77,13 @@ describe('menu-model-registry', () => {
                     });
                 }
             });
-            const all = service.getMenu();
-            const main = all.children[0] as CompositeMenuNode;
+            const main = service.getMenu(['main'])!;
             expect(main.children.length).equals(1);
             expect(main.id, 'main');
-            expect(all.children.length).equals(1);
-            const file = main.children[0] as CompositeMenuNode;
+            const file = main.children[0] as Submenu;
             expect(file.children.length).equals(1);
             expect(file.label, 'File');
-            const openGroup = file.children[0] as CompositeMenuNode;
+            const openGroup = file.children[0] as Submenu;
             expect(openGroup.children.length).equals(2);
             expect(openGroup.label).undefined;
         });
@@ -69,16 +95,22 @@ describe('menu-model-registry', () => {
             const service = createMenuRegistry({
                 registerMenus(menuRegistry: MenuModelRegistry): void {
                     menuRegistry.registerSubmenu(fileMenu, 'File');
+                    menuRegistry.registerSubmenu(fileOpenMenu, 'Open');
+                    menuRegistry.registerSubmenu(fileCloseMenu, 'Close');
                     // open menu should not be added to open menu
-                    menuRegistry.linkSubmenu(fileOpenMenu, fileOpenMenu);
+                    try {
+                        menuRegistry.linkCompoundMenuNode({ newParentPath: fileOpenMenu, submenuPath: fileOpenMenu });
+                    } catch (e) {
+                        // expected
+                    }
                     // close menu should be added
-                    menuRegistry.linkSubmenu(fileOpenMenu, fileCloseMenu);
+                    menuRegistry.linkCompoundMenuNode({ newParentPath: fileOpenMenu, submenuPath: fileCloseMenu });
                 }
             }, {
                 registerCommands(reg: CommandRegistry): void { }
             });
-            const all = service.getMenu() as CompositeMenuNode;
-            expect(menuStructureToString(all.children[0] as CompositeMenuNode)).equals('File(0_open(1_close),1_close())');
+            const main = service.getMenu(['main']) as CompoundMenuNode;
+            expect(menuStructureToString(main)).equals('File(0_open(1_close()),1_close())');
         });
     });
 });
@@ -86,14 +118,14 @@ describe('menu-model-registry', () => {
 function createMenuRegistry(menuContrib: MenuContribution, commandContrib: CommandContribution): MenuModelRegistry {
     const cmdReg = new CommandRegistry({ getContributions: () => [commandContrib] });
     cmdReg.onStart();
-    const menuReg = new MenuModelRegistry({ getContributions: () => [menuContrib] }, cmdReg);
+    const menuReg = new MenuModelRegistry({ getContributions: () => [menuContrib] }, cmdReg, new TestMenuNodeFactory());
     menuReg.onStart();
     return menuReg;
 }
 
-function menuStructureToString(node: CompositeMenuNode): string {
+function menuStructureToString(node: CompoundMenuNode): string {
     return node.children.map(c => {
-        if (c instanceof CompositeMenuNode) {
+        if (CompoundMenuNode.is(c)) {
             return `${c.id}(${menuStructureToString(c)})`;
         }
         return c.id;

package/src/browser/open-with-service.ts

@@ -49,7 +49,7 @@ export interface OpenWithHandler {
      */
     canHandle(uri: URI): number;
     /**
-     * Test whether this handler and open the given URI
+     * Test whether this handler can open the given URI
      * and return the order of this handler in the list.
      */
     getOrder?(uri: URI): number;

package/src/browser/saveable-service.ts

@@ -222,7 +222,12 @@ export class SaveableService implements FrontendApplicationContribution {
         if (!Saveable.isDirty(widget)) {
             return false;
         }
-        if (this.autoSave !== 'off') {
+        const saveable = Saveable.get(widget);
+        if (!saveable) {
+            console.warn('Saveable.get returned undefined on a known saveable widget. This is unexpected.');
+        }
+        // Enter branch if saveable absent since we cannot check autosaveability more definitely.
+        if (this.autoSave !== 'off' && (!saveable || this.shouldAutoSave(widget, saveable))) {
             return true;
         }
         const notLastWithDocument = !Saveable.closingWidgetWouldLoseSaveable(widget, Array.from(this.saveThrottles.keys()));