@theia/plugin-ext 1.18.0-next.ed824933 → 1.21.0-next.11

package/src/hosted/browser/worker/debug-stub.ts

@@ -14,6 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
+// eslint-disable-next-line @theia/runtime-import-check
 import { DebugExtImpl } from '../../../plugin/node/debug/debug';
 import { RPCProtocol } from '../../../common/rpc-protocol';
 

package/src/hosted/node/hosted-plugin-deployer-handler.ts

@@ -17,11 +17,11 @@
 import * as fs from '@theia/core/shared/fs-extra';
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { ILogger } from '@theia/core';
-import { PluginDeployerHandler, PluginDeployerEntry, PluginEntryPoint, DeployedPlugin, PluginDependencies, Localization } from '../../common/plugin-protocol';
+import { PluginDeployerHandler, PluginDeployerEntry, PluginEntryPoint, DeployedPlugin, PluginDependencies, PluginType } from '../../common/plugin-protocol';
 import { HostedPluginReader } from './plugin-reader';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
-import { Localization as TheiaLocalization } from '@theia/core/lib/common/i18n/localization';
+import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
+import { BackendApplicationConfigProvider } from '@theia/core/lib/node/backend-application-config-provider';
 
 @injectable()
 export class HostedPluginDeployerHandler implements PluginDeployerHandler {
@@ -32,8 +32,8 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
     @inject(HostedPluginReader)
     private readonly reader: HostedPluginReader;
 
-    @inject(LocalizationProvider)
-    private readonly localizationProvider: LocalizationProvider;
+    @inject(HostedPluginLocalizationService)
+    private readonly localizationService: HostedPluginLocalizationService;
 
     private readonly deployedLocations = new Map<string, Set<string>>();
 
@@ -85,7 +85,11 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             }
             const metadata = this.reader.readMetadata(manifest);
             const dependencies: PluginDependencies = { metadata };
-            dependencies.mapping = this.reader.readDependencies(manifest);
+            // Do not resolve system (aka builtin) plugins because it should be done statically at build time.
+            const { resolveSystemPlugins = true } = BackendApplicationConfigProvider.get();
+            if (resolveSystemPlugins || entry.type !== PluginType.System) {
+                dependencies.mapping = this.reader.readDependencies(manifest);
+            }
             return dependencies;
         } catch (e) {
             console.error(`Failed to load plugin dependencies from '${pluginPath}' path`, e);
@@ -105,6 +109,8 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         for (const plugin of backendPlugins) {
             await this.deployPlugin(plugin, 'backend');
         }
+        // rebuild translation config after deployment
+        this.localizationService.buildTranslationConfig([...this.deployedBackendPlugins.values()]);
         // resolve on first deploy
         this.backendPluginsMetadataDeferred.resolve(undefined);
     }
@@ -134,9 +140,7 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             const { type } = entry;
             const deployed: DeployedPlugin = { metadata, type };
             deployed.contributes = this.reader.readContribution(manifest);
-            if (deployed.contributes?.localizations) {
-                this.localizationProvider.addLocalizations(...buildTheiaLocalizations(deployed.contributes.localizations));
-            }
+            this.localizationService.deployLocalizations(deployed);
             deployedPlugins.set(metadata.model.id, deployed);
             this.logger.info(`Deploying ${entryPoint} plugin "${metadata.model.name}@${metadata.model.version}" from "${metadata.model.entryPoint[entryPoint] || pluginPath}"`);
         } catch (e) {
@@ -162,34 +166,3 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         return true;
     }
 }
-
-function buildTheiaLocalizations(localizations: Localization[]): TheiaLocalization[] {
-    const theiaLocalizations: TheiaLocalization[] = [];
-    for (const localization of localizations) {
-        const theiaLocalization: TheiaLocalization = {
-            languageId: localization.languageId,
-            languageName: localization.languageName,
-            localizedLanguageName: localization.localizedLanguageName,
-            languagePack: true,
-            translations: {}
-        };
-        for (const translation of localization.translations) {
-            for (const [scope, value] of Object.entries(translation.contents)) {
-                for (const [key, item] of Object.entries(value)) {
-                    const translationKey = buildTheiaTranslationKey(translation.id, scope, key);
-                    theiaLocalization.translations[translationKey] = item;
-                }
-            }
-        }
-        theiaLocalizations.push(theiaLocalization);
-    }
-    return theiaLocalizations;
-}
-
-function buildTheiaTranslationKey(pluginId: string, scope: string, key: string): string {
-    const scopeSlashIndex = scope.lastIndexOf('/');
-    if (scopeSlashIndex >= 0) {
-        scope = scope.substring(scopeSlashIndex + 1);
-    }
-    return `${pluginId}/${scope}/${key}`;
-}

package/src/hosted/node/hosted-plugin-localization-service.ts

@@ -0,0 +1,201 @@
+/********************************************************************************
+ * Copyright (C) 2021 TypeFox 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import * as path from 'path';
+import * as fs from '@theia/core/shared/fs-extra';
+import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
+import { Localization } from '@theia/core/lib/common/i18n/localization';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { DeployedPlugin, Localization as PluginLocalization, PluginContribution } from '../../common';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+
+export interface VSCodeNlsConfig {
+    locale: string
+    availableLanguages: Record<string, string>
+    _languagePackSupport?: boolean
+    _languagePackId?: string
+    _translationsConfigFile?: string
+    _cacheRoot?: string
+    _corruptedFile?: string
+}
+
+@injectable()
+export class HostedPluginLocalizationService {
+
+    @inject(LocalizationProvider)
+    protected readonly localizationProvider: LocalizationProvider;
+
+    @inject(EnvVariablesServer)
+    protected readonly envVariables: EnvVariablesServer;
+
+    protected translationConfigFiles: Map<string, string> = new Map();
+
+    deployLocalizations(plugin: DeployedPlugin): void {
+        if (plugin.contributes?.localizations) {
+            this.localizationProvider.addLocalizations(...buildLocalizations(plugin.contributes.localizations));
+        }
+    }
+
+    async localizePlugin(plugin: DeployedPlugin): Promise<DeployedPlugin> {
+        const currentLanguage = this.localizationProvider.getCurrentLanguage();
+        const localization = this.localizationProvider.loadLocalization(currentLanguage);
+        const pluginPath = URI.parse(plugin.metadata.model.packageUri).fsPath;
+        const pluginId = plugin.metadata.model.id;
+        // create a shallow copy to not override the original plugin's contributes property.
+        const shallowCopy = { ...plugin };
+        try {
+            const translations = await loadPackageTranslations(pluginPath, currentLanguage);
+            shallowCopy.contributes = localizePackage(shallowCopy.contributes, translations, (key, original) => {
+                const fullKey = `${pluginId}/package/${key}`;
+                return Localization.localize(localization, fullKey, original);
+            }) as PluginContribution;
+        } catch (err) {
+            console.error(`Failed to localize plugin '${pluginId}'.`, err);
+        }
+        return shallowCopy;
+    }
+
+    getNlsConfig(): VSCodeNlsConfig {
+        const locale = this.localizationProvider.getCurrentLanguage();
+        const configFile = this.translationConfigFiles.get(locale);
+        if (locale === 'en' || !configFile) {
+            return { locale, availableLanguages: {} };
+        }
+        const cache = path.dirname(configFile);
+        return {
+            locale,
+            availableLanguages: { '*': locale },
+            _languagePackSupport: true,
+            _cacheRoot: cache,
+            _languagePackId: locale,
+            _translationsConfigFile: configFile
+        };
+    }
+
+    async buildTranslationConfig(plugins: DeployedPlugin[]): Promise<void> {
+        const configDir = URI.parse(await this.envVariables.getConfigDirUri()).fsPath;
+        const cacheDir = path.join(configDir, 'localization-cache');
+        const configs = new Map<string, Record<string, string>>();
+        for (const plugin of plugins) {
+            if (plugin.contributes?.localizations) {
+                const pluginPath = URI.parse(plugin.metadata.model.packageUri).fsPath;
+                for (const localization of plugin.contributes.localizations) {
+                    const config = configs.get(localization.languageId) || {};
+                    for (const translation of localization.translations) {
+                        const fullPath = path.join(pluginPath, translation.path);
+                        config[translation.id] = fullPath;
+                    }
+                    configs.set(localization.languageId, config);
+                }
+            }
+        }
+
+        for (const [language, config] of configs.entries()) {
+            const languageConfigDir = path.join(cacheDir, language);
+            await fs.mkdirs(languageConfigDir);
+            const configFile = path.join(languageConfigDir, `nls.config.${language}.json`);
+            this.translationConfigFiles.set(language, configFile);
+            await fs.writeJson(configFile, config);
+        }
+    }
+}
+
+function buildLocalizations(localizations: PluginLocalization[]): Localization[] {
+    const theiaLocalizations: Localization[] = [];
+    for (const localization of localizations) {
+        const theiaLocalization: Localization = {
+            languageId: localization.languageId,
+            languageName: localization.languageName,
+            localizedLanguageName: localization.localizedLanguageName,
+            languagePack: true,
+            translations: {}
+        };
+        for (const translation of localization.translations) {
+            for (const [scope, value] of Object.entries(translation.contents)) {
+                for (const [key, item] of Object.entries(value)) {
+                    const translationKey = buildTranslationKey(translation.id, scope, key);
+                    theiaLocalization.translations[translationKey] = item;
+                }
+            }
+        }
+        theiaLocalizations.push(theiaLocalization);
+    }
+    return theiaLocalizations;
+}
+
+function buildTranslationKey(pluginId: string, scope: string, key: string): string {
+    return `${pluginId}/${Localization.transformKey(scope)}/${key}`;
+}
+
+interface PackageTranslation {
+    translation?: Record<string, string>
+    default?: Record<string, string>
+}
+
+async function loadPackageTranslations(pluginPath: string, locale: string): Promise<PackageTranslation> {
+    const localizedPluginPath = path.join(pluginPath, `package.nls.${locale}.json`);
+    try {
+        const defaultValue = await fs.readJson(path.join(pluginPath, 'package.nls.json'));
+        if (await fs.pathExists(localizedPluginPath)) {
+            return {
+                translation: await fs.readJson(localizedPluginPath),
+                default: defaultValue
+            };
+        }
+        return {
+            default: defaultValue
+        };
+    } catch (e) {
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+        return {};
+    }
+}
+
+const NLS_REGEX = /^%([\w\d.-]+)%$/i;
+
+function localizePackage(value: unknown, translations: PackageTranslation, callback: (key: string, defaultValue: string) => string): unknown {
+    if (typeof value === 'string') {
+        const match = NLS_REGEX.exec(value);
+        let result = value;
+        if (match) {
+            const key = match[1];
+            if (translations.translation) {
+                result = translations.translation[key];
+            } else if (translations.default) {
+                result = callback(key, translations.default[key]);
+            }
+        }
+        return result;
+    }
+    if (Array.isArray(value)) {
+        const result = [];
+        for (const item of value) {
+            result.push(localizePackage(item, translations, callback));
+        }
+        return result;
+    }
+    if (typeof value === 'object' && value) {
+        const result: Record<string, unknown> = {};
+        for (const [name, item] of Object.entries(value)) {
+            result[name] = localizePackage(item, translations, callback);
+        }
+        return result;
+    }
+    return value;
+}

package/src/hosted/node/hosted-plugin-process.ts

@@ -23,7 +23,7 @@ import { MessageType } from '../../common/rpc-protocol';
 import { HostedPluginCliContribution } from './hosted-plugin-cli-contribution';
 import * as psTree from 'ps-tree';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
+import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 
 export interface IPCConnectionOptions {
     readonly serverName: string;
@@ -56,8 +56,8 @@ export class HostedPluginProcess implements ServerPluginRunner {
     @inject(MessageService)
     protected readonly messageService: MessageService;
 
-    @inject(LocalizationProvider)
-    protected readonly localizationProvider: LocalizationProvider;
+    @inject(HostedPluginLocalizationService)
+    protected readonly localizationService: HostedPluginLocalizationService;
 
     private childProcess: cp.ChildProcess | undefined;
     private client: HostedPluginClient;
@@ -173,9 +173,7 @@ export class HostedPluginProcess implements ServerPluginRunner {
                 delete env[key];
             }
         }
-        const availableLanguages = ['en', ...this.localizationProvider.getAvailableLanguages()];
-        const locale = this.localizationProvider.getCurrentLanguage();
-        env['VSCODE_NLS_CONFIG'] = JSON.stringify({ locale, availableLanguages });
+        env['VSCODE_NLS_CONFIG'] = JSON.stringify(this.localizationService.getNlsConfig());
         // apply external env variables
         this.pluginHostEnvironmentVariables.getContributions().forEach(envVar => envVar.process(env));
         if (this.cli.extensionTestsPath) {

package/src/hosted/node/plugin-ext-hosted-backend-module.ts

@@ -33,6 +33,7 @@ import { HostedPluginCliContribution } from './hosted-plugin-cli-contribution';
 import { HostedPluginDeployerHandler } from './hosted-plugin-deployer-handler';
 import { PluginUriFactory } from './scanners/plugin-uri-factory';
 import { FilePluginUriFactory } from './scanners/file-plugin-uri-factory';
+import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 
 const commonHostedConnectionModule = ConnectionContainerModule.create(({ bind, bindBackendService }) => {
     bind(HostedPluginProcess).toSelf().inSingletonScope();
@@ -58,6 +59,7 @@ export function bindCommonHostedBackend(bind: interfaces.Bind): void {
     bind(HostedPluginReader).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(HostedPluginReader);
 
+    bind(HostedPluginLocalizationService).toSelf().inSingletonScope();
     bind(HostedPluginDeployerHandler).toSelf().inSingletonScope();
     bind(PluginDeployerHandler).toService(HostedPluginDeployerHandler);
 

package/src/hosted/node/plugin-manifest-loader.ts

@@ -14,68 +14,16 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 import * as path from 'path';
 import * as fs from '@theia/core/shared/fs-extra';
 
-const NLS_REGEX = /^%([\w\d.-]+)%$/i;
-
-export async function loadManifest(pluginPath: string, locale?: string): Promise<any> {
-    const [manifest, translations] = await Promise.all([
-        fs.readJson(path.join(pluginPath, 'package.json')),
-        loadTranslations(pluginPath, locale)
-    ]);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function loadManifest(pluginPath: string): Promise<any> {
+    const manifest = await fs.readJson(path.join(pluginPath, 'package.json'));
     // translate vscode builtins, as they are published with a prefix. See https://github.com/theia-ide/vscode-builtin-extensions/blob/master/src/republish.js#L50
     const built_prefix = '@theia/vscode-builtin-';
     if (manifest && manifest.name && manifest.name.startsWith(built_prefix)) {
         manifest.name = manifest.name.substr(built_prefix.length);
     }
-    return manifest && translations && Object.keys(translations).length ?
-        localize(manifest, translations) :
-        manifest;
-}
-
-async function loadTranslations(pluginPath: string, locale?: string): Promise<any> {
-    try {
-        const localizedPluginPath = path.join(pluginPath, `package.nls.${locale}.json`);
-        if (await fs.pathExists(localizedPluginPath)) {
-            return await fs.readJson(localizedPluginPath);
-        } else {
-            return await fs.readJson(path.join(pluginPath, 'package.nls.json'));
-        }
-    } catch (e) {
-        if (e.code !== 'ENOENT') {
-            throw e;
-        }
-        return {};
-    }
-}
-
-function localize(value: any, translations: {
-    [key: string]: string
-}): any {
-    if (typeof value === 'string') {
-        const match = NLS_REGEX.exec(value);
-        return match && translations[match[1]] || value;
-    }
-    if (Array.isArray(value)) {
-        const result = [];
-        for (const item of value) {
-            result.push(localize(item, translations));
-        }
-        return result;
-    }
-    if (value === null) {
-        return value;
-    }
-    if (typeof value === 'object') {
-        const result: { [key: string]: any } = {};
-        // eslint-disable-next-line guard-for-in
-        for (const propertyName in value) {
-            result[propertyName] = localize(value[propertyName], translations);
-        }
-        return result;
-    }
-    return value;
+    return manifest;
 }

package/src/hosted/node/plugin-service.ts

@@ -16,13 +16,11 @@
 import { injectable, inject, named, postConstruct } from '@theia/core/shared/inversify';
 import { HostedPluginServer, HostedPluginClient, PluginDeployer, GetDeployedPluginsParams, DeployedPlugin } from '../../common/plugin-protocol';
 import { HostedPluginSupport } from './hosted-plugin';
-import { ILogger, Disposable } from '@theia/core';
-import { ContributionProvider } from '@theia/core';
+import { ILogger, Disposable, ContributionProvider } from '@theia/core';
 import { ExtPluginApiProvider, ExtPluginApi } from '../../common/plugin-ext-api-contribution';
 import { HostedPluginDeployerHandler } from './hosted-plugin-deployer-handler';
 import { PluginDeployerImpl } from '../../main/node/plugin-deployer-impl';
-import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
-import { loadManifest } from './plugin-manifest-loader';
+import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 
 @injectable()
 export class HostedPluginServerImpl implements HostedPluginServer {
@@ -35,8 +33,8 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     @inject(PluginDeployer)
     protected readonly pluginDeployer: PluginDeployerImpl;
 
-    @inject(LocalizationProvider)
-    protected readonly localizationProvider: LocalizationProvider;
+    @inject(HostedPluginLocalizationService)
+    protected readonly localizationService: HostedPluginLocalizationService;
 
     @inject(ContributionProvider)
     @named(Symbol.for(ExtPluginApiProvider))
@@ -90,8 +88,7 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         if (!pluginIds.length) {
             return [];
         }
-        const locale = this.localizationProvider.getCurrentLanguage();
-        const plugins = [];
+        const plugins: DeployedPlugin[] = [];
         let extraDeployedPlugins: Map<string, DeployedPlugin> | undefined;
         for (const pluginId of pluginIds) {
             let plugin = this.deployerHandler.getDeployedPlugin(pluginId);
@@ -105,10 +102,10 @@ export class HostedPluginServerImpl implements HostedPluginServer {
                 plugin = extraDeployedPlugins.get(pluginId);
             }
             if (plugin) {
-                plugins.push(await this.localizePlugin(plugin, locale));
+                plugins.push(plugin);
             }
         }
-        return plugins;
+        return Promise.all(plugins.map(plugin => this.localizationService.localizePlugin(plugin)));
     }
 
     onMessage(pluginHostId: string, message: string): Promise<void> {
@@ -119,34 +116,4 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     getExtPluginAPI(): Promise<ExtPluginApi[]> {
         return Promise.resolve(this.extPluginAPIContributions.getContributions().map(p => p.provideApi()));
     }
-
-    protected async localizePlugin(plugin: DeployedPlugin, locale: string): Promise<DeployedPlugin> {
-        const packagePath = plugin.metadata.model.packagePath;
-        const translatedManifest = await loadManifest(packagePath, locale);
-        this.mergeContributes(plugin.contributes, translatedManifest.contributes);
-        return plugin;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    protected mergeContributes(main: any, other: any): void {
-        if (main && other) {
-            if (Array.isArray(main) && Array.isArray(other)) {
-                for (let i = 0; i < main.length && i < other.length; i++) {
-                    if (typeof main[i] === 'object' && typeof other[i] === 'object') {
-                        this.mergeContributes(main[i], other[i]);
-                    }
-                }
-            } else {
-                for (const [key, value] of Object.entries(main)) {
-                    if (key in other) {
-                        if (typeof value === 'string') {
-                            main[key] = other[key];
-                        } else if (typeof value === 'object' && typeof other[key] === 'object') {
-                            this.mergeContributes(main[key], other[key]);
-                        }
-                    }
-                }
-            }
-        }
-    }
 }

package/src/hosted/node/scanners/scanner-theia.ts

@@ -73,7 +73,7 @@ import {
     ProblemPatternContribution,
     TaskDefinition
 } from '@theia/task/lib/common/task-protocol';
-import { ColorDefinition } from '@theia/core/lib/browser/color-registry';
+import { ColorDefinition } from '@theia/core/lib/common/color';
 import { ResourceLabelFormatter } from '@theia/core/lib/common/label-protocol';
 import { PluginUriFactory } from './plugin-uri-factory';
 
@@ -217,7 +217,7 @@ export class TheiaPluginScanner implements PluginScanner {
 
                 for (const location of Object.keys(viewsContainers)) {
                     const containers = this.readViewsContainers(viewsContainers[location], rawPlugin);
-                    const loc = location === 'activitybar' ? 'left' : location;
+                    const loc = location === 'activitybar' ? 'left' : location === 'panel' ? 'bottom' : location;
                     if (contributions.viewsContainers[loc]) {
                         contributions.viewsContainers[loc] = contributions.viewsContainers[loc].concat(containers);
                     } else {
@@ -381,6 +381,7 @@ export class TheiaPluginScanner implements PluginScanner {
             throw new Error(`Could not read json file '${packageTranslation.path}'.`);
         }
         translation.id = packageTranslation.id;
+        translation.path = packageTranslation.path;
         return translation;
     }
 
@@ -553,10 +554,13 @@ export class TheiaPluginScanner implements PluginScanner {
     }
 
     private readViewContainer(rawViewContainer: PluginPackageViewContainer, pck: PluginPackage): ViewContainer {
+        const themeIcon = rawViewContainer.icon.startsWith('$(') ? rawViewContainer.icon : undefined;
+        const iconUrl = this.toPluginUrl(pck, rawViewContainer.icon);
         return {
             id: rawViewContainer.id,
             title: rawViewContainer.title,
-            iconUrl: this.toPluginUrl(pck, rawViewContainer.icon)
+            iconUrl,
+            themeIcon,
         };
     }
 

package/src/main/browser/callhierarchy/callhierarchy-type-converters.ts

@@ -151,7 +151,9 @@ export function toDefinition(definition: model.CallHierarchyDefinition | undefin
         selectionRange: toRange(definition.selectionRange),
         symbolName: definition.name,
         symbolKind: SymbolKindConverter.toSymbolKind(definition.kind),
-        containerName: undefined
+        containerName: undefined,
+        tags: definition.tags,
+        data: definition.data,
     };
 }
 
@@ -161,7 +163,9 @@ export function fromDefinition(definition: CallHierarchyDefinition): model.CallH
         range: fromRange(definition.location.range),
         selectionRange: fromRange(definition.selectionRange),
         name: definition.symbolName,
-        kind: SymbolKindConverter.fromSymbolKind(definition.symbolKind)
+        kind: SymbolKindConverter.fromSymbolKind(definition.symbolKind),
+        tags: definition.tags,
+        data: definition.data,
     };
 }
 

package/src/main/browser/custom-editors/custom-editor-opener.tsx

@@ -17,9 +17,8 @@
 import { inject } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
 import { ApplicationShell, OpenerOptions, OpenHandler, Widget, WidgetManager } from '@theia/core/lib/browser';
-import { CustomEditorPriority, CustomEditorSelector } from '../../../common';
+import { CustomEditor, CustomEditorPriority, CustomEditorSelector } from '../../../common';
 import * as glob from './glob';
-import { CustomEditor } from '../../../common';
 import { CustomEditorWidget } from './custom-editor-widget';
 import { v4 } from 'uuid';
 import { Emitter } from '@theia/core';
@@ -37,10 +36,14 @@ export class CustomEditorOpener implements OpenHandler {
         @inject(ApplicationShell) protected readonly shell: ApplicationShell,
         @inject(WidgetManager) protected readonly widgetManager: WidgetManager
     ) {
-        this.id = `custom-editor-${this.editor.viewType}`;
+        this.id = CustomEditorOpener.toCustomEditorId(this.editor.viewType);
         this.label = this.editor.displayName;
     }
 
+    static toCustomEditorId(editorViewType: string): string {
+        return `custom-editor-${editorViewType}`;
+    }
+
     canHandle(uri: URI): number {
         if (this.matches(this.editor.selector, uri)) {
             return this.getPriority();
@@ -52,7 +55,8 @@ export class CustomEditorOpener implements OpenHandler {
         switch (this.editor.priority) {
             case CustomEditorPriority.default: return 500;
             case CustomEditorPriority.builtin: return 400;
-            case CustomEditorPriority.option: return 300;
+            /** `option` should not open the custom-editor by default. */
+            case CustomEditorPriority.option: return 1;
             default: return 200;
         }
     }

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

@@ -20,7 +20,7 @@
 // some code copied and modified from https://github.com/microsoft/vscode/blob/53eac52308c4611000a171cc7bf1214293473c78/src/vs/workbench/api/browser/mainThreadCustomEditors.ts
 
 import { interfaces } from '@theia/core/shared/inversify';
-import { MAIN_RPC_CONTEXT, CustomEditorsMain, CustomEditorsExt, CustomTextEditorCapabilities } from '../../../common/plugin-api-rpc';
+import { MAIN_RPC_CONTEXT, CustomEditorsMain, CustomEditorsExt, CustomTextEditorCapabilities, EditorPosition } from '../../../common/plugin-api-rpc';
 import { RPCProtocol } from '../../../common/rpc-protocol';
 import { HostedPluginSupport } from '../../../hosted/browser/hosted-plugin';
 import { PluginCustomEditorRegistry } from './plugin-custom-editor-registry';
@@ -43,7 +43,6 @@ import { ApplicationShell, DefaultUriLabelProviderContribution, Saveable, SaveOp
 import { WebviewOptions, WebviewPanelOptions, ViewColumn } from '@theia/plugin';
 import { WebviewWidgetIdentifier } from '../webview/webview';
 import { EditorPreferences } from '@theia/editor/lib/browser';
-import { EditorPosition } from '../../../common/plugin-api-rpc';
 
 const enum CustomEditorModelType {
     Custom,