@theia/plugin-ext 1.25.0-next.4 → 1.25.0-next.42

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

@@ -14,17 +14,17 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { NotificationMain } from '../../common/plugin-api-rpc';
+import { NotificationExt, NotificationMain, MAIN_RPC_CONTEXT } from '../../common';
 import { ProgressService, Progress, ProgressMessage } from '@theia/core/lib/common';
 import { interfaces } from '@theia/core/shared/inversify';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 
 export class NotificationMainImpl implements NotificationMain, Disposable {
-
     private readonly progressService: ProgressService;
     private readonly progressMap = new Map<string, Progress>();
     private readonly progress2Work = new Map<string, number>();
+    private readonly proxy: NotificationExt;
 
     protected readonly toDispose = new DisposableCollection(
         Disposable.create(() => { /* mark as not disposed */ })
@@ -32,6 +32,7 @@ export class NotificationMainImpl implements NotificationMain, Disposable {
 
     constructor(rpc: RPCProtocol, container: interfaces.Container) {
         this.progressService = container.get(ProgressService);
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.NOTIFICATION_EXT);
     }
 
     dispose(): void {
@@ -39,8 +40,15 @@ export class NotificationMainImpl implements NotificationMain, Disposable {
     }
 
     async $startProgress(options: NotificationMain.StartProgressOptions): Promise<string> {
+        const onDidCancel = () => {
+            // If the map does not contain current id, it has already stopped and should not be cancelled
+            if (this.progressMap.has(id)) {
+                this.proxy.$acceptProgressCanceled(id);
+            }
+        };
+
         const progressMessage = this.mapOptions(options);
-        const progress = await this.progressService.showProgress(progressMessage);
+        const progress = await this.progressService.showProgress(progressMessage, onDidCancel);
         const id = progress.id;
         this.progressMap.set(id, progress);
         this.progress2Work.set(id, 0);
@@ -58,10 +66,11 @@ export class NotificationMainImpl implements NotificationMain, Disposable {
 
     $stopProgress(id: string): void {
         const progress = this.progressMap.get(id);
+
         if (progress) {
-            progress.cancel();
             this.progressMap.delete(id);
             this.progress2Work.delete(id);
+            progress.cancel();
         }
     }
 

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

@@ -78,6 +78,7 @@ import { UndoRedoService } from './custom-editors/undo-redo-service';
 import { WebviewFrontendSecurityWarnings } from './webview/webview-frontend-security-warnings';
 import { PluginAuthenticationServiceImpl } from './plugin-authentication-service';
 import { AuthenticationService } from '@theia/core/lib/browser/authentication-service';
+import { bindTreeViewDecoratorUtilities, TreeViewDecoratorService } from './view/tree-view-decorator-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -142,6 +143,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     bind(ViewContextKeyService).toSelf().inSingletonScope();
 
+    bindTreeViewDecoratorUtilities(bind);
     bind(PluginTreeViewNodeLabelProvider).toSelf().inSingletonScope();
     bind(LabelProviderContribution).toService(PluginTreeViewNodeLabelProvider);
     bind(WidgetFactory).toDynamicValue(({ container }) => ({
@@ -160,6 +162,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
                 tree: PluginTree,
                 model: PluginTreeModel,
                 widget: TreeViewWidget,
+                decoratorService: TreeViewDecoratorService
             });
             child.bind(TreeViewWidgetIdentifier).toConstantValue(identifier);
             return child.get(TreeWidget);

package/src/main/browser/status-bar-message-registry-main.ts

@@ -39,21 +39,33 @@ export class StatusBarMessageRegistryMainImpl implements StatusBarMessageRegistr
     }
 
     async $setMessage(id: string,
+        name: string | undefined,
         text: string | undefined,
         priority: number,
         alignment: number,
         color: string | undefined,
+        backgroundColor: string | undefined,
         tooltip: string | undefined,
         command: string | undefined,
+        accessibilityInformation: types.AccessibilityInformation,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         args: any[] | undefined): Promise<void> {
+        const ariaLabel = accessibilityInformation?.label;
+        const role = accessibilityInformation?.role;
+
         const entry = {
+            name,
             text: text || '',
+            ariaLabel,
+            role,
             priority,
             alignment: alignment === types.StatusBarAlignment.Left ? StatusBarAlignment.LEFT : StatusBarAlignment.RIGHT,
             color: color && (this.colorRegistry.getCurrentColor(color) || color),
+            // In contrast to color, the backgroundColor must be a theme color. Thus, do not hand in the plain string if it cannot be resolved.
+            backgroundColor: backgroundColor && (this.colorRegistry.getCurrentColor(backgroundColor)),
             tooltip,
             command,
+            accessibilityInformation,
             args
         };
 

package/src/main/browser/view/tree-view-decorator-service.ts

@@ -0,0 +1,52 @@
+/********************************************************************************
+ * Copyright (C) 2021 1C-Soft LLC 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 { inject, injectable, interfaces, named } from '@theia/core/shared/inversify';
+import { AbstractTreeDecoratorService, TreeDecorator } from '@theia/core/lib/browser/tree/tree-decorator';
+import { bindContributionProvider, ContributionProvider } from '@theia/core';
+import { TreeNode } from '@theia/core/lib/browser';
+import { TreeItem, Uri } from '@theia/plugin';
+import URI from '@theia/core/lib/common/uri';
+import { FileTreeDecoratorAdapter } from '@theia/filesystem/lib/browser';
+
+export const TreeViewDecorator = Symbol('TreeViewDecorator');
+
+@injectable()
+export class TreeViewDecoratorAdapter extends FileTreeDecoratorAdapter {
+    protected override getUriForNode(node: TreeNode | TreeItem): string | undefined {
+        if (this.isTreeItem(node)) {
+            return new URI(node.resourceUri).toString();
+        }
+    }
+
+    protected isTreeItem(node: object | undefined): node is TreeItem & { resourceUri: Uri } {
+        const candidate = node as TreeItem;
+        return !!candidate && 'resourceUri' in candidate && !!candidate.resourceUri;
+    }
+}
+
+@injectable()
+export class TreeViewDecoratorService extends AbstractTreeDecoratorService {
+    constructor(@inject(ContributionProvider) @named(TreeViewDecorator) contributions: ContributionProvider<TreeDecorator>) {
+        super(contributions.getContributions());
+    }
+}
+
+export function bindTreeViewDecoratorUtilities(bind: interfaces.Bind): void {
+    bind(TreeViewDecoratorAdapter).toSelf().inSingletonScope();
+    bindContributionProvider(bind, TreeViewDecorator);
+    bind(TreeViewDecorator).toService(TreeViewDecoratorAdapter);
+}

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

@@ -45,6 +45,7 @@ import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import * as markdownit from '@theia/core/shared/markdown-it';
 import { isMarkdownString } from '../../../plugin/markdown-string';
 import { LabelParser } from '@theia/core/lib/browser/label-parser';
+import { AccessibilityInformation } from '@theia/plugin';
 
 export const TREE_NODE_HYPERLINK = 'theia-TreeNodeHyperlink';
 export const VIEW_ITEM_CONTEXT_MENU: MenuPath = ['view-item-context-menu'];
@@ -63,6 +64,7 @@ export interface TreeViewNode extends SelectableTreeNode {
     tooltip?: string;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     description?: string | boolean | any;
+    accessibilityInformation?: AccessibilityInformation;
 }
 export namespace TreeViewNode {
     export function is(arg: TreeNode | undefined): arg is TreeViewNode {
@@ -159,6 +161,7 @@ export class PluginTree extends TreeImpl {
             tooltip: item.tooltip,
             contextValue: item.contextValue,
             command: item.command,
+            accessibilityInformation: item.accessibilityInformation,
         };
         const node = this.getNode(item.id);
         if (item.collapsibleState !== undefined && item.collapsibleState !== TreeViewItemCollapsibleState.None) {
@@ -301,6 +304,14 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
             id: node.id
         };
 
+        if (node.accessibilityInformation) {
+            attrs = {
+                ...attrs,
+                'aria-label': node.accessibilityInformation.label,
+                'role': node.accessibilityInformation.role
+            };
+        }
+
         if (node.tooltip && isMarkdownString(node.tooltip)) {
             // Render markdown in custom tooltip
             const tooltip = this.markdownIt.render(node.tooltip.value);
@@ -344,8 +355,11 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
         return this.contextKeys.with({ view: this.id, viewItem: node.contextValue }, () => {
             const menu = this.menus.getMenu(VIEW_ITEM_INLINE_MENU);
             const arg = this.toTreeViewSelection(node);
+            const inlineCommands = menu.children.filter((item): item is ActionMenuNode => item instanceof ActionMenuNode);
+            const tailDecorations = super.renderTailDecorations(node, props);
             return <React.Fragment>
-                {menu.children.map((item, index) => item instanceof ActionMenuNode && this.renderInlineCommand(item, index, arg))}
+                {inlineCommands.length > 0 && <div className={TREE_NODE_SEGMENT_CLASS}>{inlineCommands.map((item, index) => this.renderInlineCommand(item, index, arg))}</div>}
+                {tailDecorations !== undefined && <div className={TREE_NODE_SEGMENT_CLASS}>{super.renderTailDecorations(node, props)}</div>}
             </React.Fragment>;
         });
     }

package/src/plugin/comments.ts

@@ -171,7 +171,7 @@ export class CommentsExtImpl implements CommentsExt {
 
         const documentData = this._documents.getDocumentData(URI.revive(uriComponents));
         if (documentData) {
-            const ranges: theia.Range[] | undefined = await commentController.commentingRangeProvider!.provideCommentingRanges(documentData.document, token);
+            const ranges: theia.Range[] | undefined | null = await commentController.commentingRangeProvider!.provideCommentingRanges(documentData.document, token);
             if (ranges) {
                 return ranges.map(x => fromRange(x));
             }

package/src/plugin/languages/call-hierarchy.ts

@@ -16,11 +16,11 @@
 
 import { URI } from '@theia/core/shared/vscode-uri';
 import * as theia from '@theia/plugin';
-import * as Converter from '../type-converters';
 import { DocumentsExtImpl } from '../documents';
-import * as model from '../../common/plugin-api-rpc-model';
+import * as dto from '../../common/plugin-api-rpc-model';
 import * as rpc from '../../common/plugin-api-rpc';
 import * as types from '../types-impl';
+import { fromRange } from '../type-converters';
 
 export class CallHierarchyAdapter {
 
@@ -29,9 +29,12 @@ export class CallHierarchyAdapter {
         private readonly documents: DocumentsExtImpl
     ) { }
 
+    protected sessionIds = 0;
+    protected readonly cache = new Map<string, Map<string, theia.CallHierarchyItem>>();
+
     async provideRootDefinition(
         resource: URI, position: rpc.Position, token: theia.CancellationToken
-    ): Promise<model.CallHierarchyDefinition | model.CallHierarchyDefinition[] | undefined> {
+    ): Promise<dto.CallHierarchyItem[] | undefined> {
         const documentData = this.documents.getDocumentData(resource);
         if (!documentData) {
             return Promise.reject(new Error(`There is no document for ${resource}`));
@@ -48,83 +51,74 @@ export class CallHierarchyAdapter {
         if (!definition) {
             return undefined;
         }
-
-        return Array.isArray(definition) ? definition.map(item => this.fromCallHierarchyItem(item)) : this.fromCallHierarchyItem(definition);
+        const sessionId = (this.sessionIds++).toString(36);
+        this.cache.set(sessionId, new Map());
+        return Array.isArray(definition) ? definition.map(item => this.fromCallHierarchyItem(item, sessionId)) : [this.fromCallHierarchyItem(definition, sessionId)];
     }
 
-    async provideCallers(definition: model.CallHierarchyDefinition, token: theia.CancellationToken): Promise<model.CallHierarchyReference[] | undefined> {
+    async provideCallers(definition: dto.CallHierarchyItem, token: theia.CancellationToken): Promise<dto.CallHierarchyIncomingCall[] | undefined> {
         const callers = await this.provider.provideCallHierarchyIncomingCalls(this.toCallHierarchyItem(definition), token);
         if (!callers) {
             return undefined;
         }
 
-        return callers.map(item => this.fromCallHierarchyIncomingCall(item));
+        return callers.map(item => this.fromCallHierarchyIncomingCall(item, definition._sessionId!));
     }
 
-    async provideCallees(definition: model.CallHierarchyDefinition, token: theia.CancellationToken): Promise<model.CallHierarchyReference[] | undefined> {
+    async provideCallees(definition: dto.CallHierarchyItem, token: theia.CancellationToken): Promise<dto.CallHierarchyOutgoingCall[] | undefined> {
         const callees = await this.provider.provideCallHierarchyOutgoingCalls(this.toCallHierarchyItem(definition), token);
         if (!callees) {
             return undefined;
         }
 
-        return callees.map(item => this.fromCallHierarchyOutgoingCall(item));
+        return callees.map(item => this.fromCallHierarchyOutgoingCall(item, definition._sessionId!));
     }
 
-    private fromCallHierarchyItem(item: theia.CallHierarchyItem): model.CallHierarchyDefinition {
-        return {
+    private fromCallHierarchyItem(item: theia.CallHierarchyItem, sessionId: string): dto.CallHierarchyItem {
+        const sessionCache = this.cache.get(sessionId)!;
+        const itemId = sessionCache.size.toString(36);
+        const definition: dto.CallHierarchyItem = {
             uri: item.uri,
-            range: this.fromRange(item.range),
-            selectionRange: this.fromRange(item.selectionRange),
+            range: fromRange(item.range),
+            selectionRange: fromRange(item.selectionRange),
             name: item.name,
             kind: item.kind,
             tags: item.tags,
-            data: item.data,
-        };
-    }
-
-    private fromRange(range: theia.Range): model.Range {
-        return {
-            startLineNumber: range.start.line + 1,
-            startColumn: range.start.character + 1,
-            endLineNumber: range.end.line + 1,
-            endColumn: range.end.character + 1,
+            _itemId: itemId,
+            _sessionId: sessionId,
         };
+        sessionCache.set(itemId, item);
+        return definition;
     }
 
-    private toRange(range: model.Range): types.Range {
-        return new types.Range(
-            range.startLineNumber - 1,
-            range.startColumn - 1,
-            range.endLineNumber - 1,
-            range.endColumn - 1,
-        );
-    }
-
-    private toCallHierarchyItem(definition: model.CallHierarchyDefinition): theia.CallHierarchyItem {
-        const item = new types.CallHierarchyItem(
-            Converter.SymbolKind.toSymbolKind(definition.kind),
-            definition.name,
-            definition.detail ? definition.detail : '',
-            URI.revive(definition.uri),
-            this.toRange(definition.range),
-            this.toRange(definition.selectionRange),
-        );
-        item.tags = definition.tags;
-        item.data = definition.data;
-        return item;
+    private toCallHierarchyItem(definition: dto.CallHierarchyItem): theia.CallHierarchyItem {
+        const cached = this.cache.get(definition._sessionId!)?.get(definition._itemId!);
+        if (!cached) {
+            throw new Error(`Found no cached item corresponding to ${definition.name} in ${definition.uri.path} with ID ${definition.data}.`);
+        }
+        return cached;
     }
 
-    private fromCallHierarchyIncomingCall(caller: theia.CallHierarchyIncomingCall): model.CallHierarchyReference {
+    private fromCallHierarchyIncomingCall(caller: theia.CallHierarchyIncomingCall, sessionId: string): dto.CallHierarchyIncomingCall {
         return {
-            callerDefinition: this.fromCallHierarchyItem(caller.from),
-            references: caller.fromRanges.map(l => this.fromRange(l))
+            from: this.fromCallHierarchyItem(caller.from, sessionId),
+            fromRanges: caller.fromRanges.map(r => fromRange(r))
         };
     }
 
-    protected fromCallHierarchyOutgoingCall(caller: theia.CallHierarchyOutgoingCall): model.CallHierarchyReference {
+    protected fromCallHierarchyOutgoingCall(caller: theia.CallHierarchyOutgoingCall, sessionId: string): dto.CallHierarchyOutgoingCall {
         return {
-            callerDefinition: this.fromCallHierarchyItem(caller.to),
-            references: caller.fromRanges.map(this.fromRange.bind(this)),
+            to: this.fromCallHierarchyItem(caller.to, sessionId),
+            fromRanges: caller.fromRanges.map(r => fromRange(r)),
         };
     }
+
+    releaseSession(session?: string): Promise<boolean> {
+        if (session !== undefined) {
+            return Promise.resolve(this.cache.delete(session));
+        } else {
+            this.cache.clear();
+            return Promise.resolve(true);
+        }
+    }
 }

package/src/plugin/languages/lens.ts

@@ -71,7 +71,7 @@ export class CodeLensAdapter {
             return undefined;
         }
 
-        let newLens: theia.CodeLens | undefined;
+        let newLens: theia.CodeLens | undefined | null;
         if (typeof this.provider.resolveCodeLens === 'function' && !lens.isResolved) {
             newLens = await this.provider.resolveCodeLens(lens, token);
             if (token.isCancellationRequested) {

package/src/plugin/languages.ts

@@ -59,9 +59,10 @@ import {
     CodeAction,
     FoldingRange,
     SelectionRange,
-    CallHierarchyDefinition,
-    CallHierarchyReference,
-    ChainedCacheId
+    ChainedCacheId,
+    CallHierarchyItem,
+    CallHierarchyIncomingCall,
+    CallHierarchyOutgoingCall,
 } from '../common/plugin-api-rpc-model';
 import { CompletionAdapter } from './languages/completion';
 import { Diagnostics } from './languages/diagnostics';
@@ -612,17 +613,21 @@ export class LanguagesExtImpl implements LanguagesExt {
 
     $provideRootDefinition(
         handle: number, resource: UriComponents, location: Position, token: theia.CancellationToken
-    ): Promise<CallHierarchyDefinition | CallHierarchyDefinition[] | undefined> {
+    ): Promise<CallHierarchyItem[] | undefined> {
         return this.withAdapter(handle, CallHierarchyAdapter, adapter => adapter.provideRootDefinition(URI.revive(resource), location, token), undefined);
     }
 
-    $provideCallers(handle: number, definition: CallHierarchyDefinition, token: theia.CancellationToken): Promise<CallHierarchyReference[] | undefined> {
+    $provideCallers(handle: number, definition: CallHierarchyItem, token: theia.CancellationToken): Promise<CallHierarchyIncomingCall[] | undefined> {
         return this.withAdapter(handle, CallHierarchyAdapter, adapter => adapter.provideCallers(definition, token), undefined);
     }
 
-    $provideCallees(handle: number, definition: CallHierarchyDefinition, token: theia.CancellationToken): Promise<CallHierarchyReference[] | undefined> {
+    $provideCallees(handle: number, definition: CallHierarchyItem, token: theia.CancellationToken): Promise<CallHierarchyOutgoingCall[] | undefined> {
         return this.withAdapter(handle, CallHierarchyAdapter, adapter => adapter.provideCallees(definition, token), undefined);
     }
+
+    $releaseCallHierarchy(handle: number, session?: string): Promise<boolean> {
+        return this.withAdapter(handle, CallHierarchyAdapter, adapter => adapter.releaseSession(session), false);
+    }
     // ### Call Hierarchy Provider end
 
     // #region semantic coloring

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

@@ -233,6 +233,7 @@ export class DebugExtImpl implements DebugExt {
         const session = this.sessions.get(sessionId);
         if (session) {
             this.onDidTerminateDebugSessionEmitter.fire(session);
+            this.sessions.delete(sessionId);
         }
     }
 
@@ -322,7 +323,6 @@ export class DebugExtImpl implements DebugExt {
         const debugAdapterSession = this.sessions.get(sessionId);
         if (debugAdapterSession) {
             await debugAdapterSession.stop();
-            this.sessions.delete(sessionId);
         }
     }
 
@@ -346,12 +346,20 @@ export class DebugExtImpl implements DebugExt {
         return { provider, type };
     }
 
-    async $provideDebugConfigurationsByHandle(handle: number, workspaceFolderUri: string | undefined): Promise<theia.DebugConfiguration[]> {
+    async $provideDebugConfigurationsByHandle(
+        handle: number,
+        workspaceFolderUri: string | undefined
+    ): Promise<theia.DebugConfiguration[]> {
         const { provider, type } = this.getConfigurationProviderRecord(handle);
 
-        const configurations = await provider.provideDebugConfigurations?.(this.toWorkspaceFolder(workspaceFolderUri));
+        const configurations = await provider.provideDebugConfigurations?.(
+            this.toWorkspaceFolder(workspaceFolderUri)
+        );
+
         if (!configurations) {
-            throw new Error('nothing returned from DebugConfigurationProvider.provideDebugConfigurations, type: ' + type);
+            throw new Error(
+                'nothing returned from DebugConfigurationProvider.provideDebugConfigurations, type: ' + type
+            );
         }
 
         return configurations;
@@ -361,88 +369,24 @@ export class DebugExtImpl implements DebugExt {
         handle: number,
         workspaceFolderUri: string | undefined,
         debugConfiguration: theia.DebugConfiguration
-    ): Promise<theia.DebugConfiguration | undefined> {
-
+    ): Promise<theia.DebugConfiguration | undefined | null> {
         const { provider } = this.getConfigurationProviderRecord(handle);
-        return provider.resolveDebugConfiguration?.(this.toWorkspaceFolder(workspaceFolderUri), debugConfiguration);
+        return provider.resolveDebugConfiguration?.(
+            this.toWorkspaceFolder(workspaceFolderUri),
+            debugConfiguration
+        );
     }
 
     async $resolveDebugConfigurationWithSubstitutedVariablesByHandle(
         handle: number,
         workspaceFolderUri: string | undefined,
         debugConfiguration: theia.DebugConfiguration
-    ): Promise<theia.DebugConfiguration | undefined> {
-
+    ): Promise<theia.DebugConfiguration | undefined | null> {
         const { provider } = this.getConfigurationProviderRecord(handle);
-        return provider.resolveDebugConfigurationWithSubstitutedVariables?.(this.toWorkspaceFolder(workspaceFolderUri), debugConfiguration);
-    }
-
-    async $provideDebugConfigurations(debugType: string, workspaceFolderUri: string | undefined, dynamic: boolean = false): Promise<theia.DebugConfiguration[]> {
-        let result: theia.DebugConfiguration[] = [];
-
-        const trigger = dynamic ? DebugConfigurationProviderTriggerKind.Dynamic : DebugConfigurationProviderTriggerKind.Initial;
-        const providers = this.configurationProviders
-            .filter(p => p.type === debugType && p.trigger === trigger)
-            .map(p => p.provider);
-
-        for (const provider of providers) {
-            if (provider.provideDebugConfigurations) {
-                result = result.concat(await provider.provideDebugConfigurations(this.toWorkspaceFolder(workspaceFolderUri)) || []);
-            }
-        }
-
-        return result;
-    }
-
-    async $resolveDebugConfigurations(debugConfiguration: theia.DebugConfiguration, workspaceFolderUri: string | undefined): Promise<theia.DebugConfiguration | undefined> {
-        let current = debugConfiguration;
-
-        const providers = this.configurationProviders
-            .filter(p => p.type === debugConfiguration.type || p.type === '*')
-            .map(p => p.provider);
-
-        for (const provider of providers) {
-            if (provider.resolveDebugConfiguration) {
-                try {
-                    const next = await provider.resolveDebugConfiguration(this.toWorkspaceFolder(workspaceFolderUri), current);
-                    if (next) {
-                        current = next;
-                    } else {
-                        return current;
-                    }
-                } catch (e) {
-                    console.error(e);
-                }
-            }
-        }
-
-        return current;
-    }
-
-    async $resolveDebugConfigurationWithSubstitutedVariables(debugConfiguration: theia.DebugConfiguration, workspaceFolderUri: string | undefined):
-        Promise<theia.DebugConfiguration | undefined> {
-        let current = debugConfiguration;
-
-        const providers = this.configurationProviders
-            .filter(p => p.type === debugConfiguration.type || p.type === '*')
-            .map(p => p.provider);
-
-        for (const provider of providers) {
-            if (provider.resolveDebugConfigurationWithSubstitutedVariables) {
-                try {
-                    const next = await provider.resolveDebugConfigurationWithSubstitutedVariables(this.toWorkspaceFolder(workspaceFolderUri), current);
-                    if (next) {
-                        current = next;
-                    } else {
-                        return current;
-                    }
-                } catch (e) {
-                    console.error(e);
-                }
-            }
-        }
-
-        return current;
+        return provider.resolveDebugConfigurationWithSubstitutedVariables?.(
+            this.toWorkspaceFolder(workspaceFolderUri),
+            debugConfiguration
+        );
     }
 
     protected async createDebugAdapterTracker(session: theia.DebugSession): Promise<theia.DebugAdapterTracker> {

package/src/plugin/notification.ts

@@ -23,6 +23,7 @@ import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export class NotificationExtImpl implements NotificationExt {
     private readonly proxy: NotificationMain;
+    private mapProgressIdToCancellationSource: Map<string, CancellationTokenSource> = new Map();
 
     constructor(rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.NOTIFICATION_MAIN);
@@ -32,13 +33,20 @@ export class NotificationExtImpl implements NotificationExt {
         options: ProgressOptions,
         task: (progress: Progress<{ message?: string; increment?: number }>, token: CancellationToken) => PromiseLike<R>
     ): Promise<R> {
+        const source = new CancellationTokenSource();
         const id = new Deferred<string>();
-        const tokenSource = new CancellationTokenSource();
-        const progress = task({ report: async item => this.proxy.$updateProgress(await id.promise, item)}, tokenSource.token);
+        const progress = task({ report: async item => this.proxy.$updateProgress(await id.promise, item)}, source.token);
         const title = options.title ? options.title : '';
         const location = this.mapLocation(options.location);
         const cancellable = options.cancellable;
+
         id.resolve(await this.proxy.$startProgress({ title, location, cancellable }));
+
+        if (cancellable) {
+            const progressId = await id.promise;
+            this.mapProgressIdToCancellationSource.set(progressId, source);
+        }
+
         const stop = async () => this.proxy.$stopProgress(await id.promise);
         const promise = Promise.all([
             progress,
@@ -48,6 +56,14 @@ export class NotificationExtImpl implements NotificationExt {
         return progress;
     }
 
+    public $acceptProgressCanceled(id: string): void {
+        const source = this.mapProgressIdToCancellationSource.get(id);
+        if (source) {
+            source.cancel();
+            this.mapProgressIdToCancellationSource.delete(id);
+        }
+    }
+
     protected mapLocation(location: ProgressLocation | { viewId: string }): string | undefined {
         if (typeof location === 'object') {
             return location.viewId;