@theia/plugin-ext 1.28.0-next.3 → 1.28.0-next.30

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

@@ -0,0 +1,259 @@
+// *****************************************************************************
+// 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { CommandRegistry, Disposable, MenuCommandAdapter, MenuPath, SelectionService, UriSelection } from '@theia/core';
+import { ResourceContextKey } from '@theia/core/lib/browser/resource-context-key';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
+import { TreeWidgetSelection } from '@theia/core/lib/browser/tree/tree-widget-selection';
+import { ScmRepository } from '@theia/scm/lib/browser/scm-repository';
+import { ScmService } from '@theia/scm/lib/browser/scm-service';
+import { TimelineItem } from '@theia/timeline/lib/common/timeline-model';
+import { ScmCommandArg, TimelineCommandArg, TreeViewSelection } from '../../../common';
+import { PluginScmProvider, PluginScmResource, PluginScmResourceGroup } from '../scm-main';
+import { TreeViewWidget } from '../view/tree-view-widget';
+import { CodeEditorWidgetUtil, codeToTheiaMappings, ContributionPoint } from './vscode-theia-menu-mappings';
+import { TAB_BAR_TOOLBAR_CONTEXT_MENU } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+
+export type ArgumentAdapter = (...args: unknown[]) => unknown[];
+
+export class ReferenceCountingSet<T> {
+    protected readonly references: Map<T, number>;
+    constructor(initialMembers?: Iterable<T>) {
+        this.references = new Map();
+        if (initialMembers) {
+            for (const member of initialMembers) {
+                this.add(member);
+            }
+        }
+    }
+
+    add(newMember: T): ReferenceCountingSet<T> {
+        const value = this.references.get(newMember) ?? 0;
+        this.references.set(newMember, value + 1);
+        return this;
+    }
+
+    /** @returns true if the deletion results in the removal of the element from the set */
+    delete(member: T): boolean {
+        const value = this.references.get(member);
+        if (value === undefined) { } else if (value <= 1) {
+            this.references.delete(member);
+            return true;
+        } else {
+            this.references.set(member, value - 1);
+        }
+        return false;
+    }
+
+    has(maybeMember: T): boolean {
+        return this.references.has(maybeMember);
+    }
+}
+
+@injectable()
+export class PluginMenuCommandAdapter implements MenuCommandAdapter {
+    @inject(CommandRegistry) protected readonly commandRegistry: CommandRegistry;
+    @inject(CodeEditorWidgetUtil) protected readonly codeEditorUtil: CodeEditorWidgetUtil;
+    @inject(ScmService) protected readonly scmService: ScmService;
+    @inject(SelectionService) protected readonly selectionService: SelectionService;
+    @inject(ResourceContextKey) protected readonly resourceContextKey: ResourceContextKey;
+
+    protected readonly commands = new ReferenceCountingSet<string>();
+    protected readonly argumentAdapters = new Map<string, ArgumentAdapter>();
+    protected readonly separator = ':)(:';
+
+    @postConstruct()
+    protected init(): void {
+        const toCommentArgs: ArgumentAdapter = (...args) => this.toCommentArgs(...args);
+        const firstArgOnly: ArgumentAdapter = (...args) => [args[0]];
+        const noArgs: ArgumentAdapter = () => [];
+        const toScmArgs: ArgumentAdapter = (...args) => this.toScmArgs(...args);
+        const selectedResource = () => this.getSelectedResources();
+        const widgetURI: ArgumentAdapter = widget => this.codeEditorUtil.is(widget) ? [this.codeEditorUtil.getResourceUri(widget)] : [];
+        (<Array<[ContributionPoint, ArgumentAdapter | undefined]>>[
+            ['comments/comment/context', toCommentArgs],
+            ['comments/comment/title', toCommentArgs],
+            ['comments/commentThread/context', toCommentArgs],
+            ['debug/callstack/context', firstArgOnly],
+            ['debug/toolBar', noArgs],
+            ['editor/context', selectedResource],
+            ['editor/title', widgetURI],
+            ['editor/title/context', selectedResource],
+            ['explorer/context', selectedResource],
+            ['scm/resourceFolder/context', toScmArgs],
+            ['scm/resourceGroup/context', toScmArgs],
+            ['scm/resourceState/context', toScmArgs],
+            ['scm/title', () => this.toScmArg(this.scmService.selectedRepository)],
+            ['timeline/item/context', (...args) => this.toTimelineArgs(...args)],
+            ['view/item/context', (...args) => this.toTreeArgs(...args)],
+            ['view/title', noArgs],
+        ]).forEach(([contributionPoint, adapter]) => {
+            if (adapter) {
+                const paths = codeToTheiaMappings.get(contributionPoint);
+                if (paths) {
+                    paths.forEach(([path]) => this.addArgumentAdapter(path, adapter));
+                }
+            }
+        });
+        this.addArgumentAdapter(TAB_BAR_TOOLBAR_CONTEXT_MENU, widgetURI);
+    }
+
+    canHandle(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): number {
+        if (this.commands.has(command) && this.getArgumentAdapterForMenu(menuPath)) {
+            return 500;
+        }
+        return -1;
+    }
+
+    executeCommand(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): Promise<unknown> {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.executeCommand(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isVisible(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isVisible(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isEnabled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isEnabled(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isToggled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isToggled(command, ...argumentAdapter(...commandArgs));
+    }
+
+    protected getAdapterOrThrow(menuPath: MenuPath): ArgumentAdapter {
+        const argumentAdapter = this.getArgumentAdapterForMenu(menuPath);
+        if (!argumentAdapter) {
+            throw new Error('PluginMenuCommandAdapter attempted to execute command for unregistered menu: ' + JSON.stringify(menuPath));
+        }
+        return argumentAdapter;
+    }
+
+    addCommand(commandId: string): Disposable {
+        this.commands.add(commandId);
+        return Disposable.create(() => this.commands.delete(commandId));
+    }
+
+    protected getArgumentAdapterForMenu(menuPath: MenuPath): ArgumentAdapter | undefined {
+        return this.argumentAdapters.get(menuPath.join(this.separator));
+    }
+
+    protected addArgumentAdapter(menuPath: MenuPath, adapter: ArgumentAdapter): void {
+        this.argumentAdapters.set(menuPath.join(this.separator), adapter);
+    }
+
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+
+    protected toCommentArgs(...args: any[]): any[] {
+        const arg = args[0];
+        if ('text' in arg) {
+            if ('commentUniqueId' in arg) {
+                return [{
+                    commentControlHandle: arg.thread.controllerHandle,
+                    commentThreadHandle: arg.thread.commentThreadHandle,
+                    text: arg.text,
+                    commentUniqueId: arg.commentUniqueId
+                }];
+            }
+            return [{
+                commentControlHandle: arg.thread.controllerHandle,
+                commentThreadHandle: arg.thread.commentThreadHandle,
+                text: arg.text
+            }];
+        }
+        return [{
+            commentControlHandle: arg.thread.controllerHandle,
+            commentThreadHandle: arg.thread.commentThreadHandle,
+            commentUniqueId: arg.commentUniqueId
+        }];
+    }
+
+    protected toScmArgs(...args: any[]): any[] {
+        const scmArgs: any[] = [];
+        for (const arg of args) {
+            const scmArg = this.toScmArg(arg);
+            if (scmArg) {
+                scmArgs.push(scmArg);
+            }
+        }
+        return scmArgs;
+    }
+
+    protected toScmArg(arg: any): ScmCommandArg | undefined {
+        if (arg instanceof ScmRepository && arg.provider instanceof PluginScmProvider) {
+            return {
+                sourceControlHandle: arg.provider.handle
+            };
+        }
+        if (arg instanceof PluginScmResourceGroup) {
+            return {
+                sourceControlHandle: arg.provider.handle,
+                resourceGroupHandle: arg.handle
+            };
+        }
+        if (arg instanceof PluginScmResource) {
+            return {
+                sourceControlHandle: arg.group.provider.handle,
+                resourceGroupHandle: arg.group.handle,
+                resourceStateHandle: arg.handle
+            };
+        }
+    }
+
+    protected toTimelineArgs(...args: any[]): any[] {
+        const timelineArgs: any[] = [];
+        const arg = args[0];
+        timelineArgs.push(this.toTimelineArg(arg));
+        timelineArgs.push(CodeUri.parse(arg.uri));
+        timelineArgs.push(arg.source ?? '');
+        return timelineArgs;
+    }
+
+    protected toTimelineArg(arg: TimelineItem): TimelineCommandArg {
+        return {
+            timelineHandle: arg.handle,
+            source: arg.source,
+            uri: arg.uri
+        };
+    }
+
+    protected toTreeArgs(...args: any[]): any[] {
+        const treeArgs: any[] = [];
+        for (const arg of args) {
+            if (TreeViewSelection.is(arg)) {
+                treeArgs.push(arg);
+            }
+        }
+        return treeArgs;
+    }
+
+    protected getSelectedResources(): [CodeUri | TreeViewSelection | undefined, CodeUri[] | undefined] {
+        const selection = this.selectionService.selection;
+        const firstMember = TreeWidgetSelection.is(selection) && selection.source instanceof TreeViewWidget && selection[0]
+            ? selection.source.toTreeViewSelection(selection[0])
+            : (UriSelection.getUri(selection) ?? this.resourceContextKey.get())?.['codeUri'];
+        const secondMember = TreeWidgetSelection.is(selection)
+            ? UriSelection.getUris(selection).map(uri => uri['codeUri'])
+            : undefined;
+        return [firstMember, secondMember];
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+}

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

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { MenuPath } from '@theia/core';
+import { SHELL_TABBAR_CONTEXT_MENU } from '@theia/core/lib/browser';
+import { Navigatable } from '@theia/core/lib/browser/navigatable';
+import { injectable } from '@theia/core/shared/inversify';
+import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
+import { DebugStackFramesWidget } from '@theia/debug/lib/browser/view/debug-stack-frames-widget';
+import { DebugThreadsWidget } from '@theia/debug/lib/browser/view/debug-threads-widget';
+import { EditorWidget, EDITOR_CONTEXT_MENU } from '@theia/editor/lib/browser';
+import { NAVIGATOR_CONTEXT_MENU } from '@theia/navigator/lib/browser/navigator-contribution';
+import { ScmTreeWidget } from '@theia/scm/lib/browser/scm-tree-widget';
+import { TIMELINE_ITEM_CONTEXT_MENU } from '@theia/timeline/lib/browser/timeline-tree-widget';
+import { COMMENT_CONTEXT, COMMENT_THREAD_CONTEXT, COMMENT_TITLE } from '../comments/comment-thread-widget';
+import { VIEW_ITEM_CONTEXT_MENU } from '../view/tree-view-widget';
+import { WebviewWidget } from '../webview/webview';
+
+export const PLUGIN_EDITOR_TITLE_MENU = ['plugin_editor/title'];
+export const PLUGIN_SCM_TITLE_MENU = ['plugin_scm/title'];
+export const PLUGIN_VIEW_TITLE_MENU = ['plugin_view/title'];
+
+export const implementedVSCodeContributionPoints = [
+    'comments/comment/context',
+    'comments/comment/title',
+    'comments/commentThread/context',
+    'debug/callstack/context',
+    'editor/context',
+    'editor/title',
+    'editor/title/context',
+    'explorer/context',
+    'scm/resourceFolder/context',
+    'scm/resourceGroup/context',
+    'scm/resourceState/context',
+    'scm/title',
+    'timeline/item/context',
+    'view/item/context',
+    'view/title'
+] as const;
+
+export type ContributionPoint = (typeof implementedVSCodeContributionPoints)[number];
+
+/** The values are combinations of MenuPath and `when` clause, if any */
+export const codeToTheiaMappings = new Map<ContributionPoint, Array<[MenuPath] | [MenuPath, string]>>([
+    ['comments/comment/context', [[COMMENT_CONTEXT]]],
+    ['comments/comment/title', [[COMMENT_TITLE]]],
+    ['comments/commentThread/context', [[COMMENT_THREAD_CONTEXT]]],
+    ['debug/callstack/context', [[DebugStackFramesWidget.CONTEXT_MENU], [DebugThreadsWidget.CONTEXT_MENU]]],
+    ['editor/context', [[EDITOR_CONTEXT_MENU]]],
+    ['editor/title', [[PLUGIN_EDITOR_TITLE_MENU]]],
+    ['editor/title/context', [[SHELL_TABBAR_CONTEXT_MENU, 'resourceSet']]],
+    ['explorer/context', [[NAVIGATOR_CONTEXT_MENU]]],
+    ['scm/resourceFolder/context', [[ScmTreeWidget.RESOURCE_FOLDER_CONTEXT_MENU]]],
+    ['scm/resourceGroup/context', [[ScmTreeWidget.RESOURCE_GROUP_CONTEXT_MENU]]],
+    ['scm/resourceState/context', [[ScmTreeWidget.RESOURCE_CONTEXT_MENU]]],
+    ['scm/title', [[PLUGIN_SCM_TITLE_MENU]]],
+    ['timeline/item/context', [[TIMELINE_ITEM_CONTEXT_MENU]]],
+    ['view/item/context', [[VIEW_ITEM_CONTEXT_MENU]]],
+    ['view/title', [[PLUGIN_VIEW_TITLE_MENU]]],
+]);
+
+type CodeEditorWidget = EditorWidget | WebviewWidget;
+@injectable()
+export class CodeEditorWidgetUtil {
+    is(arg: unknown): arg is CodeEditorWidget {
+        return arg instanceof EditorWidget || arg instanceof WebviewWidget;
+    }
+    getResourceUri(editor: CodeEditorWidget): CodeUri | undefined {
+        const resourceUri = Navigatable.is(editor) && editor.getResourceUri();
+        return resourceUri ? resourceUri['codeUri'] : undefined;
+    }
+}

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

@@ -222,7 +222,9 @@ export class PluginContributionHandler {
                     pushContribution(`grammar.language.${language}.scope`, () => this.grammarsRegistry.mapLanguageIdToTextmateGrammar(language, grammar.scope));
                     pushContribution(`grammar.language.${language}.configuration`, () => this.grammarsRegistry.registerGrammarConfiguration(language, {
                         embeddedLanguages: this.convertEmbeddedLanguages(grammar.embeddedLanguages, logWarning),
-                        tokenTypes: this.convertTokenTypes(grammar.tokenTypes)
+                        tokenTypes: this.convertTokenTypes(grammar.tokenTypes),
+                        balancedBracketSelectors: grammar.balancedBracketScopes ?? ['*'],
+                        unbalancedBracketSelectors: grammar.balancedBracketScopes,
                     }));
                 }
                 // activate grammars only once everything else is loaded.

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

@@ -35,7 +35,7 @@ import { PluginWidget } from './plugin-ext-widget';
 import { PluginFrontendViewContribution } from './plugin-frontend-view-contribution';
 import { PluginExtDeployCommandService } from './plugin-ext-deploy-command';
 import { EditorModelService } from './text-editor-model-service';
-import { CodeEditorWidgetUtil, MenusContributionPointHandler } from './menus/menus-contribution-handler';
+import { MenusContributionPointHandler } from './menus/menus-contribution-handler';
 import { PluginContributionHandler } from './plugin-contribution-handler';
 import { PluginViewRegistry, PLUGIN_VIEW_CONTAINER_FACTORY_ID, PLUGIN_VIEW_FACTORY_ID, PLUGIN_VIEW_DATA_FACTORY_ID } from './view/plugin-view-registry';
 import { TextContentResourceResolver } from './workspace-main';
@@ -78,6 +78,8 @@ import { WebviewFrontendSecurityWarnings } from './webview/webview-frontend-secu
 import { PluginAuthenticationServiceImpl } from './plugin-authentication-service';
 import { AuthenticationService } from '@theia/core/lib/browser/authentication-service';
 import { bindTreeViewDecoratorUtilities, TreeViewDecoratorService } from './view/tree-view-decorator-service';
+import { CodeEditorWidgetUtil } from './menus/vscode-theia-menu-mappings';
+import { PluginMenuCommandAdapter } from './menus/plugin-menu-command-adapter';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -213,6 +215,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(LabelProviderContribution).toService(PluginIconThemeService);
 
     bind(MenusContributionPointHandler).toSelf().inSingletonScope();
+    bind(PluginMenuCommandAdapter).toSelf().inSingletonScope();
     bind(CodeEditorWidgetUtil).toSelf().inSingletonScope();
     bind(KeybindingsContributionPointHandler).toSelf().inSingletonScope();
     bind(PluginContributionHandler).toSelf().inSingletonScope();

package/src/main/browser/plugin-shared-style.ts

@@ -111,7 +111,6 @@ export class PluginSharedStyle {
         const iconClass = 'plugin-icon-' + this.iconSequence++;
         const toDispose = new DisposableCollection();
         toDispose.push(this.insertRule('.' + iconClass, theme => `
-                display: inline-block;
                 background-position: 2px;
                 width: ${size}px;
                 height: ${size}px;

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

@@ -430,4 +430,14 @@ export class ScmMainImpl implements ScmMain {
 
         repository.input.placeholder = placeholder;
     }
+
+    $setInputBoxVisible(sourceControlHandle: number, visible: boolean): void {
+        const repository = this.repositories.get(sourceControlHandle);
+
+        if (!repository) {
+            return;
+        }
+
+        repository.input.visible = visible;
+    }
 }

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

@@ -127,8 +127,11 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, Disposable
                 destroyTermOnClose: true,
                 useServerTitle: false,
                 attributes: options.attributes,
-                isPseudoTerminal,
+                isPseudoTerminal
             });
+            if (options.message) {
+                terminal.writeLine(options.message);
+            }
             terminal.start();
             return terminal.id;
         } catch (error) {

package/src/main/browser/view/tree-view-widget.tsx

@@ -399,14 +399,14 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     protected renderInlineCommand(node: ActionMenuNode, index: number, tabbable: boolean, arg: any): React.ReactNode {
         const { icon } = node;
-        if (!icon || !this.commands.isVisible(node.action.commandId, arg) || !node.action.when || !this.contextKeys.match(node.action.when)) {
+        if (!icon || !this.commands.isVisible(node.command, arg) || !node.when || !this.contextKeys.match(node.when)) {
             return false;
         }
         const className = [TREE_NODE_SEGMENT_CLASS, TREE_NODE_TAIL_CLASS, icon, ACTION_ITEM, 'theia-tree-view-inline-action'].join(' ');
         const tabIndex = tabbable ? 0 : undefined;
         return <div key={index} className={className} title={node.label} tabIndex={tabIndex} onClick={e => {
             e.stopPropagation();
-            this.commands.executeCommand(node.action.commandId, arg);
+            this.commands.executeCommand(node.command, arg);
         }} />;
     }
 

package/src/plugin/debug/debug-ext.ts

@@ -23,13 +23,15 @@ import { PluginPackageDebuggersContribution } from '../../common/plugin-protocol
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { CommandRegistryImpl } from '../command-registry';
 import { ConnectionImpl } from '../../common/connection';
-import { Disposable, Breakpoint as BreakpointExt, SourceBreakpoint, FunctionBreakpoint, Location, Range } from '../types-impl';
+import { DEBUG_SCHEME, SCHEME_PATTERN } from '@theia/debug/lib/common/debug-uri-utils';
+import { Disposable, Breakpoint as BreakpointExt, SourceBreakpoint, FunctionBreakpoint, Location, Range, URI as URIImpl } from '../types-impl';
 import { PluginDebugAdapterSession } from './plugin-debug-adapter-session';
 import { PluginDebugAdapterTracker } from './plugin-debug-adapter-tracker';
 import uuid = require('uuid');
 import { DebugAdapter } from '@theia/debug/lib/common/debug-model';
 import { PluginDebugAdapterCreator } from './plugin-debug-adapter-creator';
 import { NodeDebugAdapterCreator } from '../node/debug/plugin-node-debug-adapter-creator';
+import { DebugProtocol } from 'vscode-debugprotocol';
 
 interface ConfigurationProviderRecord {
     handle: number;
@@ -176,6 +178,27 @@ export class DebugExtImpl implements DebugExt {
         return this.proxy.$stopDebugging(session?.id);
     }
 
+    asDebugSourceUri(source: theia.DebugProtocolSource, session?: theia.DebugSession): theia.Uri {
+        return this.getDebugSourceUri(source, session?.id);
+    }
+
+    private getDebugSourceUri(raw: DebugProtocol.Source, sessionId?: string): theia.Uri {
+        if (raw.sourceReference && raw.sourceReference > 0) {
+            let query = 'ref=' + String(raw.sourceReference);
+            if (sessionId) {
+                query += `&session=${sessionId}`;
+            }
+            return URIImpl.from({ scheme: DEBUG_SCHEME, path: raw.path ?? '', query });
+        }
+        if (!raw.path) {
+            throw new Error('Unrecognized source type: ' + JSON.stringify(raw));
+        }
+        if (raw.path.match(SCHEME_PATTERN)) {
+            return URIImpl.parse(raw.path);
+        }
+        return URIImpl.file(raw.path);
+    }
+
     registerDebugAdapterDescriptorFactory(debugType: string, factory: theia.DebugAdapterDescriptorFactory): Disposable {
         if (this.descriptorFactories.has(debugType)) {
             throw new Error(`Descriptor factory for ${debugType} has been already registered`);
@@ -279,13 +302,13 @@ export class DebugExtImpl implements DebugExt {
         this.onDidChangeBreakpointsEmitter.fire({ added: a, removed: r, changed: c });
     }
 
-    protected toBreakpointExt({ functionName, location, enabled, condition, hitCondition, logMessage }: Breakpoint): BreakpointExt | undefined {
+    protected toBreakpointExt({ functionName, location, enabled, condition, hitCondition, logMessage, id }: Breakpoint): BreakpointExt | undefined {
         if (location) {
             const range = new Range(location.range.startLineNumber, location.range.startColumn, location.range.endLineNumber, location.range.endColumn);
-            return new SourceBreakpoint(new Location(URI.revive(location.uri), range), enabled, condition, hitCondition, logMessage);
+            return new SourceBreakpoint(new Location(URI.revive(location.uri), range), enabled, condition, hitCondition, logMessage, id);
         }
         if (functionName) {
-            return new FunctionBreakpoint(functionName!, enabled, condition, hitCondition, logMessage);
+            return new FunctionBreakpoint(functionName!, enabled, condition, hitCondition, logMessage, id);
         }
         return undefined;
     }
@@ -305,7 +328,9 @@ export class DebugExtImpl implements DebugExt {
                     return response.body;
                 }
                 return Promise.reject(new Error(response.message ?? 'custom request failed'));
-            }
+            },
+            getDebugProtocolBreakpoint: async (breakpoint: Breakpoint) =>
+                this.proxy.$getDebugProtocolBreakpoint(sessionId, breakpoint.id)
         };
 
         const tracker = await this.createDebugAdapterTracker(theiaSession);

package/src/plugin/debug/plugin-debug-adapter-session.ts

@@ -61,6 +61,10 @@ export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
         return this.theiaSession.customRequest(command, args);
     }
 
+    async getDebugProtocolBreakpoint(breakpoint: theia.Breakpoint): Promise<theia.DebugProtocolBreakpoint | undefined> {
+        return this.theiaSession.getDebugProtocolBreakpoint(breakpoint);
+    }
+
     protected override onDebugAdapterError(error: Error): void {
         if (this.tracker.onError) {
             this.tracker.onError(error);

package/src/plugin/languages/signature.ts

@@ -52,6 +52,7 @@ export class SignatureHelpAdapter {
         if (!value) {
             return undefined;
         }
+        value.activeParameter = value.signatures[value.activeSignature].activeParameter ?? value.activeParameter;
         const id = this.idSequence++;
         this.cache.set(id, value);
         return Converter.SignatureHelp.from(id, value);
@@ -65,7 +66,8 @@ export class SignatureHelpAdapter {
             if (saved) {
                 activeSignatureHelp = saved;
                 activeSignatureHelp.activeSignature = revivedSignatureHelp.activeSignature;
-                activeSignatureHelp.activeParameter = revivedSignatureHelp.activeParameter;
+                const { activeSignature } = revivedSignatureHelp;
+                activeSignatureHelp.activeParameter = revivedSignatureHelp.signatures[activeSignature].activeParameter ?? revivedSignatureHelp.activeParameter;
             } else {
                 activeSignatureHelp = revivedSignatureHelp;
             }

package/src/plugin/node/debug/debug.spec.ts

@@ -0,0 +1,94 @@
+/********************************************************************************
+ * Copyright (C) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { DebugSession } from '@theia/plugin';
+import * as chai from 'chai';
+import { ProxyIdentifier, RPCProtocol } from '../../../common/rpc-protocol';
+
+import { DebugExtImpl } from '../../debug/debug-ext';
+
+const expect = chai.expect;
+
+describe('Debug API', () => {
+
+    describe('#asDebugSourceURI', () => {
+
+        const mockRPCProtocol: RPCProtocol = {
+            getProxy<T>(_proxyId: ProxyIdentifier<T>): T {
+                return {} as T;
+            },
+            set<T, R extends T>(_id: ProxyIdentifier<T>, instance: R): R {
+                return instance;
+            },
+            dispose(): void {
+                // Nothing
+            }
+        };
+
+        const debug = new DebugExtImpl(mockRPCProtocol);
+
+        it('should use sourceReference, path and sessionId', () => {
+            const source = {
+                sourceReference: 3,
+                path: 'test/path'
+            };
+            const session = { id: 'test-session' } as DebugSession;
+            const uri = debug.asDebugSourceUri(source, session);
+            expect(uri.toString(true)).to.be.equal('debug:test/path?ref=3&session=test-session');
+        });
+
+        it('should use sourceReference', () => {
+            const source = {
+                sourceReference: 5
+            };
+            const uri = debug.asDebugSourceUri(source);
+            expect(uri.toString(true)).to.be.equal('debug:?ref=5');
+        });
+
+        it('should use sourceReference and session', () => {
+            const source = {
+                sourceReference: 5
+            };
+            const session = { id: 'test-session' } as DebugSession;
+            const uri = debug.asDebugSourceUri(source, session);
+            expect(uri.toString(true)).to.be.equal('debug:?ref=5&session=test-session');
+        });
+
+        it('should use sourceReference and path', () => {
+            const source = {
+                sourceReference: 4,
+                path: 'test/path'
+            };
+            const uri = debug.asDebugSourceUri(source);
+            expect(uri.toString(true)).to.be.equal('debug:test/path?ref=4');
+        });
+
+        it('should use path', () => {
+            const source = {
+                path: 'scheme:/full/path'
+            };
+            const uri = debug.asDebugSourceUri(source);
+            expect(uri.toString(true)).to.be.equal('scheme:/full/path');
+        });
+
+        it('should use file path', () => {
+            const source = {
+                path: '/full/path'
+            };
+            const uri = debug.asDebugSourceUri(source);
+            expect(uri.toString(true)).to.be.equal('file:///full/path');
+        });
+    });
+});

package/src/plugin/plugin-context.ts

@@ -868,6 +868,9 @@ export function createAPIFactory(
             },
             removeBreakpoints(breakpoints: readonly theia.Breakpoint[]): void {
                 debugExt.removeBreakpoints(breakpoints);
+            },
+            asDebugSourceUri(source: theia.DebugProtocolSource, session?: theia.DebugSession): theia.Uri {
+                return debugExt.asDebugSourceUri(source, session);
             }
         };
 

package/src/plugin/quick-open.ts

@@ -85,6 +85,7 @@ export class QuickOpenExtImpl implements QuickOpenExt {
         const instance = ++this._instances;
 
         const widgetPromise = this.proxy.$show(instance, {
+            title: options && options.title,
             canPickMany: options && options.canPickMany,
             placeHolder: options && options.placeHolder,
             matchOnDescription: options && options.matchOnDescription,