@theia/plugin-ext 1.24.0-next.7 → 1.24.0-next.71

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

@@ -57,6 +57,17 @@ import { ObjectIdentifier } from '../../common/object-identifier';
 import { mixin } from '../../common/types';
 import { relative } from '../../common/paths-util';
 import { decodeSemanticTokensDto } from '../../common/semantic-tokens-dto';
+import * as monaco from '@theia/monaco-editor-core';
+import { ExtensionIdentifier } from '@theia/monaco-editor-core/esm/vs/platform/extensions/common/extensions';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { IMarkerService } from '@theia/monaco-editor-core/esm/vs/platform/markers/common/markers';
+import * as MonacoLanguageSelector from '@theia/monaco-editor-core/esm/vs/editor/common/languageSelector';
+import * as MonacoPath from '@theia/monaco-editor-core/esm/vs/base/common/path';
+import { IRelativePattern } from '@theia/monaco-editor-core/esm/vs/base/common/glob';
+
+interface RegistrationFunction<T> {
+    (languageId: MonacoLanguageSelector.LanguageSelector, service: T): Disposable;
+}
 
 @injectable()
 export class LanguagesMainImpl implements LanguagesMain, Disposable {
@@ -126,13 +137,14 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     }
 
     $registerCompletionSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], triggerCharacters: string[], supportsResolveDetails: boolean): void {
-        this.register(handle, monaco.modes.CompletionProviderRegistry.register(this.toLanguageSelector(selector), {
-            triggerCharacters,
-            provideCompletionItems: (model, position, context, token) => this.provideCompletionItems(handle, model, position, context, token),
-            resolveCompletionItem: supportsResolveDetails
-                ? (suggestion, token) => Promise.resolve(this.resolveCompletionItem(handle, suggestion, token))
-                : undefined
-        }));
+        this.register(handle,
+            (monaco.languages.registerCompletionItemProvider as RegistrationFunction<monaco.languages.CompletionItemProvider>)(this.toLanguageSelector(selector), {
+                triggerCharacters,
+                provideCompletionItems: (model, position, context, token) => this.provideCompletionItems(handle, model, position, context, token),
+                resolveCompletionItem: supportsResolveDetails
+                    ? (suggestion, token) => Promise.resolve(this.resolveCompletionItem(handle, suggestion, token))
+                    : undefined
+            }));
     }
 
     protected provideCompletionItems(handle: number, model: monaco.editor.ITextModel, position: monaco.Position,
@@ -165,19 +177,19 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDefinitionProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const definitionProvider = this.createDefinitionProvider(handle);
-        this.register(handle, monaco.languages.registerDefinitionProvider(languageSelector, definitionProvider));
+        this.register(handle, (monaco.languages.registerDefinitionProvider as RegistrationFunction<monaco.languages.DefinitionProvider>)(languageSelector, definitionProvider));
     }
 
     $registerDeclarationProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const declarationProvider = this.createDeclarationProvider(handle);
-        this.register(handle, monaco.languages.registerDeclarationProvider(languageSelector, declarationProvider));
+        this.register(handle, (monaco.languages.registerDeclarationProvider as RegistrationFunction<monaco.languages.DeclarationProvider>)(languageSelector, declarationProvider));
     }
 
     $registerReferenceProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const referenceProvider = this.createReferenceProvider(handle);
-        this.register(handle, monaco.languages.registerReferenceProvider(languageSelector, referenceProvider));
+        this.register(handle, (monaco.languages.registerReferenceProvider as RegistrationFunction<monaco.languages.ReferenceProvider>)(languageSelector, referenceProvider));
     }
 
     protected createReferenceProvider(handle: number): monaco.languages.ReferenceProvider {
@@ -208,7 +220,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerSignatureHelpProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], metadata: theia.SignatureHelpProviderMetadata): void {
         const languageSelector = this.toLanguageSelector(selector);
         const signatureHelpProvider = this.createSignatureHelpProvider(handle, metadata);
-        this.register(handle, monaco.languages.registerSignatureHelpProvider(languageSelector, signatureHelpProvider));
+        this.register(handle, (monaco.languages.registerSignatureHelpProvider as RegistrationFunction<monaco.languages.SignatureHelpProvider>)
+            (languageSelector, signatureHelpProvider));
     }
 
     $clearDiagnostics(id: string): void {
@@ -227,7 +240,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerImplementationProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const implementationProvider = this.createImplementationProvider(handle);
-        this.register(handle, monaco.languages.registerImplementationProvider(languageSelector, implementationProvider));
+        this.register(handle, (monaco.languages.registerImplementationProvider as RegistrationFunction<monaco.languages.ImplementationProvider>)
+            (languageSelector, implementationProvider));
     }
 
     protected createImplementationProvider(handle: number): monaco.languages.ImplementationProvider {
@@ -263,7 +277,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerTypeDefinitionProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const typeDefinitionProvider = this.createTypeDefinitionProvider(handle);
-        this.register(handle, monaco.languages.registerTypeDefinitionProvider(languageSelector, typeDefinitionProvider));
+        this.register(handle, (monaco.languages.registerTypeDefinitionProvider as RegistrationFunction<monaco.languages.TypeDefinitionProvider>)
+            (languageSelector, typeDefinitionProvider));
     }
 
     protected createTypeDefinitionProvider(handle: number): monaco.languages.TypeDefinitionProvider {
@@ -299,7 +314,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerHoverProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const hoverProvider = this.createHoverProvider(handle);
-        this.register(handle, monaco.languages.registerHoverProvider(languageSelector, hoverProvider));
+        this.register(handle, (monaco.languages.registerHoverProvider as RegistrationFunction<monaco.languages.HoverProvider>)(languageSelector, hoverProvider));
     }
 
     protected createHoverProvider(handle: number): monaco.languages.HoverProvider {
@@ -316,7 +331,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentHighlightProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const documentHighlightProvider = this.createDocumentHighlightProvider(handle);
-        this.register(handle, monaco.languages.registerDocumentHighlightProvider(languageSelector, documentHighlightProvider));
+        this.register(handle, (monaco.languages.registerDocumentHighlightProvider as RegistrationFunction<monaco.languages.DocumentHighlightProvider>)
+            (languageSelector, documentHighlightProvider));
     }
 
     protected createDocumentHighlightProvider(handle: number): monaco.languages.DocumentHighlightProvider {
@@ -371,7 +387,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentLinkProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const linkProvider = this.createLinkProvider(handle);
-        this.register(handle, monaco.languages.registerLinkProvider(languageSelector, linkProvider));
+        this.register(handle, (monaco.languages.registerLinkProvider as RegistrationFunction<monaco.languages.LinkProvider>)(languageSelector, linkProvider));
     }
 
     protected createLinkProvider(handle: number): monaco.languages.LinkProvider {
@@ -420,7 +436,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             lensProvider.onDidChange = emitter.event;
         }
 
-        this.register(handle, monaco.languages.registerCodeLensProvider(languageSelector, lensProvider));
+        this.register(handle, (monaco.languages.registerCodeLensProvider as RegistrationFunction<monaco.languages.CodeLensProvider>)(languageSelector, lensProvider));
     }
 
     protected createCodeLensProvider(handle: number): monaco.languages.CodeLensProvider {
@@ -462,7 +478,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerOutlineSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], displayName?: string): void {
         const languageSelector = this.toLanguageSelector(selector);
         const symbolProvider = this.createDocumentSymbolProvider(handle, displayName);
-        this.register(handle, monaco.modes.DocumentSymbolProviderRegistry.register(languageSelector, symbolProvider));
+        this.register(handle, (monaco.languages.registerDocumentSymbolProvider as RegistrationFunction<monaco.languages.DocumentSymbolProvider>)(languageSelector, symbolProvider));
     }
 
     protected createDocumentSymbolProvider(handle: number, displayName?: string): monaco.languages.DocumentSymbolProvider {
@@ -565,14 +581,13 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentFormattingSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const documentFormattingEditSupport = this.createDocumentFormattingSupport(handle, pluginInfo);
-        this.register(handle, monaco.languages.registerDocumentFormattingEditProvider(languageSelector, documentFormattingEditSupport));
+        this.register(handle, (monaco.languages.registerDocumentFormattingEditProvider as RegistrationFunction<monaco.languages.DocumentFormattingEditProvider>)
+            (languageSelector, documentFormattingEditSupport));
     }
 
     createDocumentFormattingSupport(handle: number, pluginInfo: PluginInfo): monaco.languages.DocumentFormattingEditProvider {
-        const provider: monaco.languages.DocumentFormattingEditProvider = {
-            extensionId: {
-                value: pluginInfo.id
-            },
+        const provider: monaco.languages.DocumentFormattingEditProvider & { extensionId: ExtensionIdentifier } = {
+            extensionId: new ExtensionIdentifier(pluginInfo.id),
             displayName: pluginInfo.name,
             provideDocumentFormattingEdits: (model, options, token) =>
                 this.provideDocumentFormattingEdits(handle, model, options, token)
@@ -589,14 +604,13 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerRangeFormattingSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const rangeFormattingEditProvider = this.createRangeFormattingSupport(handle, pluginInfo);
-        this.register(handle, monaco.languages.registerDocumentRangeFormattingEditProvider(languageSelector, rangeFormattingEditProvider));
+        this.register(handle, (monaco.languages.registerDocumentRangeFormattingEditProvider as RegistrationFunction<monaco.languages.DocumentRangeFormattingEditProvider>)
+            (languageSelector, rangeFormattingEditProvider));
     }
 
     createRangeFormattingSupport(handle: number, pluginInfo: PluginInfo): monaco.languages.DocumentRangeFormattingEditProvider {
-        const provider: monaco.languages.DocumentRangeFormattingEditProvider = {
-            extensionId: {
-                value: pluginInfo.id
-            },
+        const provider: monaco.languages.DocumentRangeFormattingEditProvider & { extensionId: ExtensionIdentifier } = {
+            extensionId: new ExtensionIdentifier(pluginInfo.id),
             displayName: pluginInfo.name,
             provideDocumentRangeFormattingEdits: (model, range: Range, options, token) =>
                 this.provideDocumentRangeFormattingEdits(handle, model, range, options, token)
@@ -613,7 +627,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerOnTypeFormattingProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], autoFormatTriggerCharacters: string[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const onTypeFormattingProvider = this.createOnTypeFormattingProvider(handle, autoFormatTriggerCharacters);
-        this.register(handle, monaco.languages.registerOnTypeFormattingEditProvider(languageSelector, onTypeFormattingProvider));
+        this.register(handle, (monaco.languages.registerOnTypeFormattingEditProvider as RegistrationFunction<monaco.languages.OnTypeFormattingEditProvider>)
+            (languageSelector, onTypeFormattingProvider));
     }
 
     protected createOnTypeFormattingProvider(
@@ -634,7 +649,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerFoldingRangeProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const provider = this.createFoldingRangeProvider(handle);
-        this.register(handle, monaco.languages.registerFoldingRangeProvider(languageSelector, provider));
+        this.register(handle, (monaco.languages.registerFoldingRangeProvider as RegistrationFunction<monaco.languages.FoldingRangeProvider>)(languageSelector, provider));
     }
 
     createFoldingRangeProvider(handle: number): monaco.languages.FoldingRangeProvider {
@@ -651,7 +666,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerSelectionRangeProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const provider = this.createSelectionRangeProvider(handle);
-        this.register(handle, monaco.languages.registerSelectionRangeProvider(languageSelector, provider));
+        this.register(handle, (monaco.languages.registerSelectionRangeProvider as RegistrationFunction<monaco.languages.SelectionRangeProvider>)(languageSelector, provider));
     }
 
     protected createSelectionRangeProvider(handle: number): monaco.languages.SelectionRangeProvider {
@@ -668,7 +683,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentColorProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const colorProvider = this.createColorProvider(handle);
-        this.register(handle, monaco.languages.registerColorProvider(languageSelector, colorProvider));
+        this.register(handle, (monaco.languages.registerColorProvider as RegistrationFunction<monaco.languages.DocumentColorProvider>)(languageSelector, colorProvider));
     }
 
     createColorProvider(handle: number): monaco.languages.DocumentColorProvider {
@@ -718,7 +733,9 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         const quickFixProvider = {
             provideCodeActions: (model: monaco.editor.ITextModel, range: monaco.Range,
                 context: monaco.languages.CodeActionContext, token: monaco.CancellationToken): monaco.languages.CodeActionList | Promise<monaco.languages.CodeActionList> => {
-                const markers = monaco.services.StaticServices.markerService.get().read({ resource: model.uri }).filter(m => monaco.Range.areIntersectingOrTouching(m, range));
+                const markers = StandaloneServices.get(IMarkerService)
+                    .read({ resource: model.uri })
+                    .filter(m => monaco.Range.areIntersectingOrTouching(m, range)) as monaco.editor.IMarkerData[];
                 return this.provideCodeActions(handle, model, range, { markers, only: context.only }, token);
             },
             resolveCodeAction: (codeAction: monaco.languages.CodeAction, token: monaco.CancellationToken): Promise<monaco.languages.CodeAction> =>
@@ -726,7 +743,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             providedCodeActionKinds,
             documentation
         };
-        this.register(handle, monaco.modes.CodeActionProviderRegistry.register(languageSelector, quickFixProvider));
+        this.register(handle, (monaco.languages.registerCodeActionProvider as RegistrationFunction<monaco.languages.CodeActionProvider>)(languageSelector, quickFixProvider));
     }
 
     protected async provideCodeActions(handle: number, model: monaco.editor.ITextModel,
@@ -757,7 +774,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerRenameProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], supportsResolveLocation: boolean): void {
         const languageSelector = this.toLanguageSelector(selector);
         const renameProvider = this.createRenameProvider(handle, supportsResolveLocation);
-        this.register(handle, monaco.languages.registerRenameProvider(languageSelector, renameProvider));
+        this.register(handle, (monaco.languages.registerRenameProvider as RegistrationFunction<monaco.languages.RenameProvider>)(languageSelector, renameProvider));
     }
 
     protected createRenameProvider(handle: number, supportsResolveLocation: boolean): monaco.languages.RenameProvider {
@@ -832,7 +849,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             event = emitter.event;
         }
         const provider = this.createDocumentSemanticTokensProvider(handle, legend, event);
-        this.register(handle, monaco.languages.registerDocumentSemanticTokensProvider(languageSelector, provider));
+        this.register(handle, (monaco.languages.registerDocumentSemanticTokensProvider as RegistrationFunction<monaco.languages.DocumentSemanticTokensProvider>)
+            (languageSelector, provider));
     }
 
     protected createDocumentSemanticTokensProvider(handle: number, legend: theia.SemanticTokensLegend, event?: Event<void>): monaco.languages.DocumentSemanticTokensProvider {
@@ -877,7 +895,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentRangeSemanticTokensProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], legend: theia.SemanticTokensLegend): void {
         const languageSelector = this.toLanguageSelector(selector);
         const provider = this.createDocumentRangeSemanticTokensProvider(handle, legend);
-        this.register(handle, monaco.languages.registerDocumentRangeSemanticTokensProvider(languageSelector, provider));
+        this.register(handle, (monaco.languages.registerDocumentRangeSemanticTokensProvider as RegistrationFunction<monaco.languages.DocumentRangeSemanticTokensProvider>)
+            (languageSelector, provider));
     }
 
     protected createDocumentRangeSemanticTokensProvider(handle: number, legend: theia.SemanticTokensLegend): monaco.languages.DocumentRangeSemanticTokensProvider {
@@ -905,14 +924,14 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
 
     // --- suggest
 
-    protected toLanguageSelector(filters: SerializedDocumentFilter[]): monaco.modes.LanguageSelector & LanguageSelector {
+    protected toLanguageSelector(filters: SerializedDocumentFilter[]): MonacoLanguageSelector.LanguageSelector & LanguageSelector {
         return filters.map(filter => {
-            let pattern: string | (monaco.modes.IRelativePattern & RelativePattern) | undefined;
+            let pattern: string | (IRelativePattern & RelativePattern) | undefined;
             if (typeof filter.pattern === 'string') {
                 pattern = filter.pattern;
             } else if (filter.pattern) {
                 pattern = {
-                    base: monaco.path.normalize(filter.pattern.base),
+                    base: MonacoPath.normalize(filter.pattern.base),
                     pattern: filter.pattern.pattern,
                     pathToRelative: relative
                 };

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

@@ -47,7 +47,6 @@ import { ApplicationShell } from '@theia/core/lib/browser/shell/application-shel
 import { MonacoBulkEditService } from '@theia/monaco/lib/browser/monaco-bulk-edit-service';
 import { MonacoEditorService } from '@theia/monaco/lib/browser/monaco-editor-service';
 import { UntitledResourceResolver } from './editor/untitled-resource';
-import { FileResourceResolver } from '@theia/filesystem/lib/browser';
 import { MainFileSystemEventService } from './main-file-system-event-service';
 import { LabelServiceMainImpl } from './label-service-main';
 import { TimelineMainImpl } from './timeline-main';
@@ -87,8 +86,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const openerService = container.get<OpenerService>(OpenerService);
     const shell = container.get(ApplicationShell);
     const untitledResourceResolver = container.get(UntitledResourceResolver);
-    const fileResourceResolver = container.get(FileResourceResolver);
-    const documentsMain = new DocumentsMainImpl(editorsAndDocuments, modelService, rpc, editorManager, openerService, shell, untitledResourceResolver, fileResourceResolver);
+    const documentsMain = new DocumentsMainImpl(editorsAndDocuments, modelService, rpc, editorManager, openerService, shell, untitledResourceResolver);
     rpc.set(PLUGIN_RPC_CONTEXT.DOCUMENTS_MAIN, documentsMain);
 
     const bulkEditService = container.get(MonacoBulkEditService);

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

@@ -518,13 +518,26 @@ export class MenusContributionPointHandler {
         }
         const toDispose = new DisposableCollection();
         const commandId = this.createSyntheticCommandId(menu.command, { prefix: '__plugin.menu.action.' });
+        const altId = menu.alt && this.createSyntheticCommandId(menu.alt, { prefix: '__plugin.menu.action.' });
+
+        const inline = Boolean(menu.group && /^inline/.test(menu.group));
+        const [group, order = undefined] = (menu.group || '_').split('@');
+
         const command: Command = { id: commandId };
+        const action: MenuAction = { commandId, alt: altId, order, when: menu.when };
+
         toDispose.push(this.commands.registerCommand(command, handler(menu.command)));
         toDispose.push(this.quickCommandService?.pushCommandContext(commandId, 'false'));
+        toDispose.push(this.menuRegistry.registerMenuAction(inline ? menuPath : [...menuPath, ...group.split('/')], action));
+        toDispose.push(this.onDidRegisterCommand(menu.command, pluginCommand => {
+            command.category = pluginCommand.category;
+            command.label = pluginCommand.label;
+            if (inline) {
+                command.iconClass = pluginCommand.iconClass;
+            }
+        }));
 
-        let altId: string | undefined;
-        if (menu.alt) {
-            altId = this.createSyntheticCommandId(menu.alt, { prefix: '__plugin.menu.action.' });
+        if (menu.alt && altId) {
             const alt: Command = { id: altId };
             toDispose.push(this.commands.registerCommand(alt, handler(menu.alt)));
             toDispose.push(this.quickCommandService?.pushCommandContext(altId, 'false'));
@@ -537,13 +550,9 @@ export class MenusContributionPointHandler {
             }));
         }
 
-        const { when } = menu;
-        const [group, order = undefined] = (menu.group || '_').split('@');
-        const action: MenuAction = { commandId, alt: altId, order, when };
-
         // Register a submenu if the group is in format `<submenu group>/<submenu name>/<submenu order>.../<menu group>`
-        if (group!.indexOf('/') !== -1) {
-            const groupSplit = group!.split('/');
+        if (group.includes('/')) {
+            const groupSplit = group.split('/');
             const orderSplit = (menu.submenusOrder || '').split('/');
             const paths: string[] = [];
             for (let i = 0, j = 0; i < groupSplit.length - 1; i += 2, j += 1) {
@@ -554,17 +563,7 @@ export class MenusContributionPointHandler {
                 toDispose.push(this.menuRegistry.registerSubmenu([...menuPath, ...paths], submenuLabel, { order: submenuOrder }));
             }
         }
-        const inline = /^inline/.test(group);
-        menuPath = inline ? menuPath : [...menuPath, ...group.split('/')];
-        toDispose.push(this.menuRegistry.registerMenuAction(menuPath, action));
 
-        toDispose.push(this.onDidRegisterCommand(menu.command, pluginCommand => {
-            command.category = pluginCommand.category;
-            command.label = pluginCommand.label;
-            if (inline) {
-                command.iconClass = pluginCommand.iconClass;
-            }
-        }));
         return toDispose;
     }
 

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

@@ -40,6 +40,8 @@ import { MonacoThemingService } from '@theia/monaco/lib/browser/monaco-theming-s
 import { ColorRegistry } from '@theia/core/lib/browser/color-registry';
 import { PluginIconThemeService } from './plugin-icon-theme-service';
 import { ContributionProvider } from '@theia/core/lib/common';
+import * as monaco from '@theia/monaco-editor-core';
+import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 
 @injectable()
 export class PluginContributionHandler {
@@ -360,13 +362,13 @@ export class PluginContributionHandler {
         const toDispose = new DisposableCollection();
         for (const { iconUrl, themeIcon, command, category, title, originalTitle } of contribution.commands) {
             const reference = iconUrl && this.style.toIconClass(iconUrl);
-            const icon = themeIcon && monaco.theme.ThemeIcon.fromString(themeIcon);
+            const icon = themeIcon && ThemeIcon.fromString(themeIcon);
             let iconClass;
             if (reference) {
                 toDispose.push(reference);
                 iconClass = reference.object.iconClass;
             } else if (icon) {
-                iconClass = monaco.theme.ThemeIcon.asClassName(icon);
+                iconClass = ThemeIcon.asClassName(icon);
             }
             toDispose.push(this.registerCommand({ id: command, category, label: title, originalLabel: originalTitle, iconClass }));
         }

package/src/main/browser/plugin-icon-theme-service.ts

@@ -37,6 +37,8 @@ import { Endpoint } from '@theia/core/lib/browser/endpoint';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { FileStat, FileChangeType } from '@theia/filesystem/lib/common/files';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { ILanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/languages/language';
 
 export interface PluginIconDefinition {
     iconPath: string;
@@ -519,8 +521,8 @@ export class PluginIconTheme extends PluginIconThemeDefinition implements IconTh
             } else {
                 classNames.unshift(this.fileIcon);
             }
-            const language = monaco.services.StaticServices.modeService.get().createByFilepathOrFirstLine(parsedURI['codeUri']);
-            classNames.push(this.languageIcon(language.languageIdentifier.language));
+            const language = StandaloneServices.get(ILanguageService).createByFilepathOrFirstLine(parsedURI['codeUri']);
+            classNames.push(this.languageIcon(language.languageId));
         }
         return classNames;
     }

package/src/main/browser/quick-open-main.ts

@@ -25,7 +25,8 @@ import {
     TransferInputBox,
     TransferQuickPickItems,
     TransferQuickInput,
-    TransferQuickInputButton
+    TransferQuickInputButton,
+    TransferQuickPickItemValue
 } from '../../common/plugin-api-rpc';
 import {
     InputOptions,
@@ -37,12 +38,14 @@ import {
 import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposable';
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { MonacoQuickInputService } from '@theia/monaco/lib/browser/monaco-quick-input-service';
-import * as theia from '@theia/plugin';
 import { QuickInputButtons } from '../../plugin/types-impl';
 import { getIconUris } from '../../plugin/quick-open';
+import * as monaco from '@theia/monaco-editor-core';
+import { IQuickPickItem, IQuickInput } from '@theia/monaco-editor-core/esm/vs/base/parts/quickinput/common/quickInput';
+import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 
 export interface QuickInputSession {
-    input: monaco.quickInput.IQuickInput;
+    input: IQuickInput;
     handlesToItems: Map<number, TransferQuickPickItems>;
 }
 
@@ -68,7 +71,7 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
         this.toDispose.dispose();
     }
 
-    async $show(instance: number, options: PickOptions<TransferQuickPickItems>, token: CancellationToken): Promise<number | number[] | undefined> {
+    async $show(instance: number, options: PickOptions<TransferQuickPickItemValue>, token: CancellationToken): Promise<number | number[] | undefined> {
         const contents = new Promise<TransferQuickPickItems[]>((resolve, reject) => {
             this.items[instance] = { resolve, reject };
         });
@@ -82,21 +85,14 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
             }
         };
 
-        if (options.canPickMany) {
-            return this.delegate.pick(contents, options as { canPickMany: true }, token).then(items => {
-                if (items) {
-                    return items.map(item => item.handle);
-                }
-                return undefined;
-            });
-        } else {
-            return this.delegate.pick(contents, options, token).then(item => {
-                if (item) {
-                    return item.handle;
-                }
-                return undefined;
-            });
+        const result = await this.delegate.pick<TransferQuickPickItemValue>(contents, options, token);
+
+        if (Array.isArray(result)) {
+            return result.map(({ handle }) => handle);
+        } else if (result) {
+            return result.handle;
         }
+        return undefined;
     }
 
     $setItems(instance: number, items: TransferQuickPickItems[]): Promise<any> {
@@ -119,6 +115,7 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
         const inputOptions: InputOptions = Object.create(null);
 
         if (options) {
+            inputOptions.title = options.title;
             inputOptions.password = options.password;
             inputOptions.placeHolder = options.placeHolder;
             inputOptions.valueSelection = options.valueSelection;
@@ -194,19 +191,20 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
 
     private sessions = new Map<number, QuickInputSession>();
 
-    $createOrUpdate<T extends theia.QuickPickItem>(params: TransferQuickInput): Promise<void> {
+    $createOrUpdate(params: TransferQuickInput): Promise<void> {
         const sessionId = params.id;
-        let session = this.sessions.get(sessionId);
-        if (!session) {
+        let session: QuickInputSession;
+        const candidate = this.sessions.get(sessionId);
+        if (!candidate) {
             if (params.type === 'quickPick') {
                 const quickPick = this.quickInputService.createQuickPick();
                 quickPick.onDidAccept(() => {
                     this.proxy.$acceptOnDidAccept(sessionId);
                 });
-                quickPick.onDidChangeActive((items: Array<monaco.quickInput.IQuickPickItem>) => {
+                quickPick.onDidChangeActive((items: Array<IQuickPickItem>) => {
                     this.proxy.$onDidChangeActive(sessionId, items.map(item => (item as TransferQuickPickItems).handle));
                 });
-                quickPick.onDidChangeSelection((items: Array<monaco.quickInput.IQuickPickItem>) => {
+                quickPick.onDidChangeSelection((items: Array<IQuickPickItem>) => {
                     this.proxy.$onDidChangeSelection(sessionId, items.map(item => (item as TransferQuickPickItems).handle));
                 });
                 quickPick.onDidTriggerButton((button: QuickInputButtonHandle) => {
@@ -242,6 +240,8 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
                 };
             }
             this.sessions.set(sessionId, session);
+        } else {
+            session = candidate;
         }
         if (session) {
             const { input, handlesToItems } = session;
@@ -273,7 +273,7 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
                         const { iconPath, tooltip, handle } = button;
                         if ('id' in iconPath) {
                             return {
-                                iconClass: monaco.theme.ThemeIcon.asClassName(iconPath),
+                                iconClass: ThemeIcon.asClassName(iconPath),
                                 tooltip,
                                 handle
                             };

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

@@ -44,3 +44,7 @@
 .theia-tree-view .theia-TreeNode:not(:hover):not(.theia-mod-selected) .theia-tree-view-inline-action {
     display: none;
 }
+
+.codicon.icon-inline {
+    font-size: var(--theia-ui-font-size1);
+}

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

@@ -14,6 +14,8 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import * as monaco from '@theia/monaco-editor-core';
+import { StandaloneCodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 import {
@@ -84,23 +86,23 @@ export class TextEditorMain implements Disposable {
         this.toDisposeOnEditor.push(Disposable.create(() => this.editor = undefined));
 
         if (this.editor) {
-            const monaco = this.editor.getControl();
+            const monacoEditor = this.editor.getControl();
             this.toDisposeOnEditor.push(this.editor.onSelectionChanged(_ => {
                 this.updateProperties();
             }));
-            this.toDisposeOnEditor.push(monaco.onDidChangeModel(() => {
+            this.toDisposeOnEditor.push(monacoEditor.onDidChangeModel(() => {
                 this.setEditor(undefined);
             }));
-            this.toDisposeOnEditor.push(monaco.onDidChangeCursorSelection(e => {
+            this.toDisposeOnEditor.push(monacoEditor.onDidChangeCursorSelection(e => {
                 this.updateProperties(e.source);
             }));
-            this.toDisposeOnEditor.push(monaco.onDidChangeConfiguration(() => {
+            this.toDisposeOnEditor.push(monacoEditor.onDidChangeConfiguration(() => {
                 this.updateProperties();
             }));
-            this.toDisposeOnEditor.push(monaco.onDidLayoutChange(() => {
+            this.toDisposeOnEditor.push(monacoEditor.onDidLayoutChange(() => {
                 this.updateProperties();
             }));
-            this.toDisposeOnEditor.push(monaco.onDidScrollChange(() => {
+            this.toDisposeOnEditor.push(monacoEditor.onDidScrollChange(() => {
                 this.updateProperties();
             }));
 
@@ -263,12 +265,9 @@ export class TextEditorMain implements Disposable {
     }
 
     insertSnippet(template: string, ranges: Range[], opts: UndoStopOptions): boolean {
+        const snippetController: SnippetController2 | null | undefined = this.editor?.getControl().getContribution('snippetController2');
 
-        if (!this.editor) {
-            return false;
-        }
-
-        const snippetController: SnippetController2 = this.editor!.getControl().getContribution('snippetController2');
+        if (!snippetController || !this.editor) { return false; }
 
         const selections = ranges.map(r => new monaco.Selection(r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn));
         this.editor.getControl().setSelections(selections);
@@ -283,7 +282,7 @@ export class TextEditorMain implements Disposable {
         if (!this.editor) {
             return;
         }
-        this.editor.getControl().setDecorations(key, ranges.map(option => Object.assign(option, { color: undefined })));
+        (this.editor.getControl() as unknown as StandaloneCodeEditor).setDecorations('Plugin decorations', key, ranges.map(option => Object.assign(option, { color: undefined })));
     }
 
     setDecorationsFast(key: string, _ranges: number[]): void {
@@ -295,8 +294,7 @@ export class TextEditorMain implements Disposable {
         for (let i = 0; i < len; i++) {
             ranges[i] = new monaco.Range(_ranges[4 * i], _ranges[4 * i + 1], _ranges[4 * i + 2], _ranges[4 * i + 3]);
         }
-
-        this.editor.getControl().setDecorationsFast(key, ranges);
+        (this.editor.getControl() as unknown as StandaloneCodeEditor).setDecorationsFast(key, ranges);
     }
 
     private static toMonacoSelections(selection: Selection): monaco.Selection {

package/src/main/browser/text-editors-main.ts

@@ -41,6 +41,9 @@ import { MonacoBulkEditService } from '@theia/monaco/lib/browser/monaco-bulk-edi
 import { MonacoEditorService } from '@theia/monaco/lib/browser/monaco-editor-service';
 import { theiaUritoUriComponents, UriComponents } from '../../common/uri-components';
 import { Endpoint } from '@theia/core/lib/browser/endpoint';
+import * as monaco from '@theia/monaco-editor-core';
+import { ResourceEdit } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/bulkEditService';
+import { IDecorationRenderOptions } from '@theia/monaco-editor-core/esm/vs/editor/common/editorCommon';
 
 export class TextEditorsMainImpl implements TextEditorsMain, Disposable {
 
@@ -120,7 +123,7 @@ export class TextEditorsMainImpl implements TextEditorsMain, Disposable {
     async $tryApplyWorkspaceEdit(dto: WorkspaceEditDto): Promise<boolean> {
         const workspaceEdit = toMonacoWorkspaceEdit(dto);
         try {
-            const edits = monaco.editor.ResourceEdit.convert(workspaceEdit);
+            const edits = ResourceEdit.convert(workspaceEdit);
             const { success } = await this.bulkEditService.apply(edits);
             return success;
         } catch {
@@ -135,9 +138,9 @@ export class TextEditorsMainImpl implements TextEditorsMain, Disposable {
         return Promise.resolve(this.editorsAndDocuments.getEditor(id)!.insertSnippet(template, ranges, opts));
     }
 
-    $registerTextEditorDecorationType(key: string, options: DecorationRenderOptions): void {
+    $registerTextEditorDecorationType(key: string, options: DecorationRenderOptions | IDecorationRenderOptions): void {
         this.injectRemoteUris(options);
-        this.monacoEditorService.registerDecorationType(key, options);
+        this.monacoEditorService.registerDecorationType('Plugin decoration', key, options as IDecorationRenderOptions);
         this.toDispose.push(Disposable.create(() => this.$removeTextEditorDecorationType(key)));
     }