@theia/plugin-ext 1.25.0-next.9 → 1.25.0

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

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Definition as CallHierarchyDefinition, Caller as CallHierarchyCaller, Callee as CallHierarchyCallee } from '@theia/callhierarchy/lib/browser';
+import { CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from '@theia/callhierarchy/lib/browser';
 import * as model from '../../../common/plugin-api-rpc-model';
 import * as rpc from '../../../common/plugin-api-rpc';
 import * as callhierarchy from '@theia/core/shared/vscode-languageserver-protocol';
@@ -70,136 +70,124 @@ export function toRange(range: model.Range): callhierarchy.Range {
 }
 
 export namespace SymbolKindConverter {
-    // tslint:disable-next-line:no-null-keyword
-    const fromMapping: { [kind: number]: model.SymbolKind } = Object.create(null);
-    fromMapping[callhierarchy.SymbolKind.File] = model.SymbolKind.File;
-    fromMapping[callhierarchy.SymbolKind.Module] = model.SymbolKind.Module;
-    fromMapping[callhierarchy.SymbolKind.Namespace] = model.SymbolKind.Namespace;
-    fromMapping[callhierarchy.SymbolKind.Package] = model.SymbolKind.Package;
-    fromMapping[callhierarchy.SymbolKind.Class] = model.SymbolKind.Class;
-    fromMapping[callhierarchy.SymbolKind.Method] = model.SymbolKind.Method;
-    fromMapping[callhierarchy.SymbolKind.Property] = model.SymbolKind.Property;
-    fromMapping[callhierarchy.SymbolKind.Field] = model.SymbolKind.Field;
-    fromMapping[callhierarchy.SymbolKind.Constructor] = model.SymbolKind.Constructor;
-    fromMapping[callhierarchy.SymbolKind.Enum] = model.SymbolKind.Enum;
-    fromMapping[callhierarchy.SymbolKind.Interface] = model.SymbolKind.Interface;
-    fromMapping[callhierarchy.SymbolKind.Function] = model.SymbolKind.Function;
-    fromMapping[callhierarchy.SymbolKind.Variable] = model.SymbolKind.Variable;
-    fromMapping[callhierarchy.SymbolKind.Constant] = model.SymbolKind.Constant;
-    fromMapping[callhierarchy.SymbolKind.String] = model.SymbolKind.String;
-    fromMapping[callhierarchy.SymbolKind.Number] = model.SymbolKind.Number;
-    fromMapping[callhierarchy.SymbolKind.Boolean] = model.SymbolKind.Boolean;
-    fromMapping[callhierarchy.SymbolKind.Array] = model.SymbolKind.Array;
-    fromMapping[callhierarchy.SymbolKind.Object] = model.SymbolKind.Object;
-    fromMapping[callhierarchy.SymbolKind.Key] = model.SymbolKind.Key;
-    fromMapping[callhierarchy.SymbolKind.Null] = model.SymbolKind.Null;
-    fromMapping[callhierarchy.SymbolKind.EnumMember] = model.SymbolKind.EnumMember;
-    fromMapping[callhierarchy.SymbolKind.Struct] = model.SymbolKind.Struct;
-    fromMapping[callhierarchy.SymbolKind.Event] = model.SymbolKind.Event;
-    fromMapping[callhierarchy.SymbolKind.Operator] = model.SymbolKind.Operator;
-    fromMapping[callhierarchy.SymbolKind.TypeParameter] = model.SymbolKind.TypeParameter;
-
     export function fromSymbolKind(kind: callhierarchy.SymbolKind): model.SymbolKind {
-        return fromMapping[kind] || model.SymbolKind.Property;
+        switch (kind) {
+            case callhierarchy.SymbolKind.File: return model.SymbolKind.File;
+            case callhierarchy.SymbolKind.Module: return model.SymbolKind.Module;
+            case callhierarchy.SymbolKind.Namespace: return model.SymbolKind.Namespace;
+            case callhierarchy.SymbolKind.Package: return model.SymbolKind.Package;
+            case callhierarchy.SymbolKind.Class: return model.SymbolKind.Class;
+            case callhierarchy.SymbolKind.Method: return model.SymbolKind.Method;
+            case callhierarchy.SymbolKind.Property: return model.SymbolKind.Property;
+            case callhierarchy.SymbolKind.Field: return model.SymbolKind.Field;
+            case callhierarchy.SymbolKind.Constructor: return model.SymbolKind.Constructor;
+            case callhierarchy.SymbolKind.Enum: return model.SymbolKind.Enum;
+            case callhierarchy.SymbolKind.Interface: return model.SymbolKind.Interface;
+            case callhierarchy.SymbolKind.Function: return model.SymbolKind.Function;
+            case callhierarchy.SymbolKind.Variable: return model.SymbolKind.Variable;
+            case callhierarchy.SymbolKind.Constant: return model.SymbolKind.Constant;
+            case callhierarchy.SymbolKind.String: return model.SymbolKind.String;
+            case callhierarchy.SymbolKind.Number: return model.SymbolKind.Number;
+            case callhierarchy.SymbolKind.Boolean: return model.SymbolKind.Boolean;
+            case callhierarchy.SymbolKind.Array: return model.SymbolKind.Array;
+            case callhierarchy.SymbolKind.Object: return model.SymbolKind.Object;
+            case callhierarchy.SymbolKind.Key: return model.SymbolKind.Key;
+            case callhierarchy.SymbolKind.Null: return model.SymbolKind.Null;
+            case callhierarchy.SymbolKind.EnumMember: return model.SymbolKind.EnumMember;
+            case callhierarchy.SymbolKind.Struct: return model.SymbolKind.Struct;
+            case callhierarchy.SymbolKind.Event: return model.SymbolKind.Event;
+            case callhierarchy.SymbolKind.Operator: return model.SymbolKind.Operator;
+            case callhierarchy.SymbolKind.TypeParameter: return model.SymbolKind.TypeParameter;
+            default: return model.SymbolKind.Property;
+        }
     }
-
-    // tslint:disable-next-line:no-null-keyword
-    const toMapping: { [kind: number]: callhierarchy.SymbolKind } = Object.create(null);
-    toMapping[model.SymbolKind.File] = callhierarchy.SymbolKind.File;
-    toMapping[model.SymbolKind.Module] = callhierarchy.SymbolKind.Module;
-    toMapping[model.SymbolKind.Namespace] = callhierarchy.SymbolKind.Namespace;
-    toMapping[model.SymbolKind.Package] = callhierarchy.SymbolKind.Package;
-    toMapping[model.SymbolKind.Class] = callhierarchy.SymbolKind.Class;
-    toMapping[model.SymbolKind.Method] = callhierarchy.SymbolKind.Method;
-    toMapping[model.SymbolKind.Property] = callhierarchy.SymbolKind.Property;
-    toMapping[model.SymbolKind.Field] = callhierarchy.SymbolKind.Field;
-    toMapping[model.SymbolKind.Constructor] = callhierarchy.SymbolKind.Constructor;
-    toMapping[model.SymbolKind.Enum] = callhierarchy.SymbolKind.Enum;
-    toMapping[model.SymbolKind.Interface] = callhierarchy.SymbolKind.Interface;
-    toMapping[model.SymbolKind.Function] = callhierarchy.SymbolKind.Function;
-    toMapping[model.SymbolKind.Variable] = callhierarchy.SymbolKind.Variable;
-    toMapping[model.SymbolKind.Constant] = callhierarchy.SymbolKind.Constant;
-    toMapping[model.SymbolKind.String] = callhierarchy.SymbolKind.String;
-    toMapping[model.SymbolKind.Number] = callhierarchy.SymbolKind.Number;
-    toMapping[model.SymbolKind.Boolean] = callhierarchy.SymbolKind.Boolean;
-    toMapping[model.SymbolKind.Array] = callhierarchy.SymbolKind.Array;
-    toMapping[model.SymbolKind.Object] = callhierarchy.SymbolKind.Object;
-    toMapping[model.SymbolKind.Key] = callhierarchy.SymbolKind.Key;
-    toMapping[model.SymbolKind.Null] = callhierarchy.SymbolKind.Null;
-    toMapping[model.SymbolKind.EnumMember] = callhierarchy.SymbolKind.EnumMember;
-    toMapping[model.SymbolKind.Struct] = callhierarchy.SymbolKind.Struct;
-    toMapping[model.SymbolKind.Event] = callhierarchy.SymbolKind.Event;
-    toMapping[model.SymbolKind.Operator] = callhierarchy.SymbolKind.Operator;
-    toMapping[model.SymbolKind.TypeParameter] = callhierarchy.SymbolKind.TypeParameter;
-
     export function toSymbolKind(kind: model.SymbolKind): callhierarchy.SymbolKind {
-        return toMapping[kind] || model.SymbolKind.Property;
+        switch (kind) {
+            case model.SymbolKind.File: return callhierarchy.SymbolKind.File;
+            case model.SymbolKind.Module: return callhierarchy.SymbolKind.Module;
+            case model.SymbolKind.Namespace: return callhierarchy.SymbolKind.Namespace;
+            case model.SymbolKind.Package: return callhierarchy.SymbolKind.Package;
+            case model.SymbolKind.Class: return callhierarchy.SymbolKind.Class;
+            case model.SymbolKind.Method: return callhierarchy.SymbolKind.Method;
+            case model.SymbolKind.Property: return callhierarchy.SymbolKind.Property;
+            case model.SymbolKind.Field: return callhierarchy.SymbolKind.Field;
+            case model.SymbolKind.Constructor: return callhierarchy.SymbolKind.Constructor;
+            case model.SymbolKind.Enum: return callhierarchy.SymbolKind.Enum;
+            case model.SymbolKind.Interface: return callhierarchy.SymbolKind.Interface;
+            case model.SymbolKind.Function: return callhierarchy.SymbolKind.Function;
+            case model.SymbolKind.Variable: return callhierarchy.SymbolKind.Variable;
+            case model.SymbolKind.Constant: return callhierarchy.SymbolKind.Constant;
+            case model.SymbolKind.String: return callhierarchy.SymbolKind.String;
+            case model.SymbolKind.Number: return callhierarchy.SymbolKind.Number;
+            case model.SymbolKind.Boolean: return callhierarchy.SymbolKind.Boolean;
+            case model.SymbolKind.Array: return callhierarchy.SymbolKind.Array;
+            case model.SymbolKind.Object: return callhierarchy.SymbolKind.Object;
+            case model.SymbolKind.Key: return callhierarchy.SymbolKind.Key;
+            case model.SymbolKind.Null: return callhierarchy.SymbolKind.Null;
+            case model.SymbolKind.EnumMember: return callhierarchy.SymbolKind.EnumMember;
+            case model.SymbolKind.Struct: return callhierarchy.SymbolKind.Struct;
+            case model.SymbolKind.Event: return callhierarchy.SymbolKind.Event;
+            case model.SymbolKind.Operator: return callhierarchy.SymbolKind.Operator;
+            case model.SymbolKind.TypeParameter: return callhierarchy.SymbolKind.TypeParameter;
+            default: return callhierarchy.SymbolKind.Property;
+        }
     }
 }
 
-export function toDefinition(definition: model.CallHierarchyDefinition): CallHierarchyDefinition;
-export function toDefinition(definition: model.CallHierarchyDefinition | undefined): CallHierarchyDefinition | undefined;
-export function toDefinition(definition: model.CallHierarchyDefinition | undefined): CallHierarchyDefinition | undefined {
+export function toDefinition(definition: model.CallHierarchyItem): CallHierarchyItem;
+export function toDefinition(definition: model.CallHierarchyItem | undefined): CallHierarchyItem | undefined;
+export function toDefinition(definition: model.CallHierarchyItem | undefined): CallHierarchyItem | undefined {
     if (!definition) {
         return undefined;
     }
     return {
-        location: {
-            uri: fromUriComponents(definition.uri),
-            range: toRange(definition.range)
-        },
+        ...definition,
+        kind: SymbolKindConverter.toSymbolKind(definition.kind),
+        range: toRange(definition.range),
         selectionRange: toRange(definition.selectionRange),
-        symbolName: definition.name,
-        symbolKind: SymbolKindConverter.toSymbolKind(definition.kind),
-        containerName: undefined,
-        tags: definition.tags,
-        data: definition.data,
     };
 }
 
-export function fromDefinition(definition: CallHierarchyDefinition): model.CallHierarchyDefinition {
+export function fromDefinition(definition: CallHierarchyItem): model.CallHierarchyItem {
     return {
-        uri: toUriComponents(definition.location.uri),
-        range: fromRange(definition.location.range),
-        selectionRange: fromRange(definition.selectionRange),
-        name: definition.symbolName,
-        kind: SymbolKindConverter.fromSymbolKind(definition.symbolKind),
-        tags: definition.tags,
-        data: definition.data,
+        ...definition,
+        kind: SymbolKindConverter.fromSymbolKind(definition.kind),
+        range: fromRange(definition.range),
+        selectionRange: fromRange(definition.range),
     };
 }
 
-export function toCaller(caller: model.CallHierarchyReference): CallHierarchyCaller {
+export function toCaller(caller: model.CallHierarchyIncomingCall): CallHierarchyIncomingCall {
     return {
-        callerDefinition: toDefinition(caller.callerDefinition),
-        references: caller.references.map(toRange)
+        from: toDefinition(caller.from),
+        fromRanges: caller.fromRanges.map(toRange)
     };
 }
 
-export function fromCaller(caller: CallHierarchyCaller): model.CallHierarchyReference {
+export function fromCaller(caller: CallHierarchyIncomingCall): model.CallHierarchyIncomingCall {
     return {
-        callerDefinition: fromDefinition(caller.callerDefinition),
-        references: caller.references.map(fromRange)
+        from: fromDefinition(caller.from),
+        fromRanges: caller.fromRanges.map(fromRange)
     };
 }
 
-export function toCallee(callee: model.CallHierarchyReference): CallHierarchyCallee {
+export function toCallee(callee: model.CallHierarchyOutgoingCall): CallHierarchyOutgoingCall {
     return {
-        calleeDefinition: toDefinition(callee.callerDefinition),
-        references: callee.references.map(toRange),
+        to: toDefinition(callee.to),
+        fromRanges: callee.fromRanges.map(toRange),
     };
 }
 
-export function fromCallHierarchyCallerToModelCallHierarchyIncomingCall(caller: CallHierarchyCaller): model.CallHierarchyIncomingCall {
+export function fromCallHierarchyCallerToModelCallHierarchyIncomingCall(caller: CallHierarchyIncomingCall): model.CallHierarchyIncomingCall {
     return {
-        from: fromDefinition(caller.callerDefinition),
-        fromRanges: caller.references.map(fromRange),
+        from: fromDefinition(caller.from),
+        fromRanges: caller.fromRanges.map(fromRange),
     };
 }
 
-export function fromCallHierarchyCalleeToModelCallHierarchyOutgoingCall(callee: CallHierarchyCallee): model.CallHierarchyOutgoingCall {
+export function fromCallHierarchyCalleeToModelCallHierarchyOutgoingCall(callee: CallHierarchyOutgoingCall): model.CallHierarchyOutgoingCall {
     return {
-        to: fromDefinition(callee.calleeDefinition),
-        fromRanges: callee.references.map(fromRange),
+        to: fromDefinition(callee.to),
+        fromRanges: callee.fromRanges.map(fromRange),
     };
 }

package/src/main/browser/comments/comment-thread-widget.tsx

@@ -89,6 +89,12 @@ export class CommentThreadWidget extends BaseWidget {
                 commentForm.update();
             }
         }));
+        this.toDispose.push(this._commentThread.onDidChangeCanReply(_canReply => {
+            const commentForm = this.commentFormRef.current;
+            if (commentForm) {
+                commentForm.update();
+            }
+        }));
         this.contextMenu = this.menus.getMenu(COMMENT_THREAD_CONTEXT);
         this.contextMenu.children.map(node => node instanceof ActionMenuNode && node.action.when).forEach(exp => {
             if (typeof exp === 'string') {
@@ -381,7 +387,7 @@ export class CommentForm<P extends CommentForm.Props = CommentForm.Props> extend
     override render(): React.ReactNode {
         const { commands, commentThread, contextKeyService } = this.props;
         const hasExistingComments = commentThread.comments && commentThread.comments.length > 0;
-        return <div className={'comment-form' + (this.state.expanded || commentThread.comments && commentThread.comments.length === 0 ? ' expand' : '')}>
+        return commentThread.canReply ? <div className={'comment-form' + (this.state.expanded || commentThread.comments && commentThread.comments.length === 0 ? ' expand' : '')}>
             <div className={'theia-comments-input-message-container'}>
                 <textarea className={'theia-comments-input-message theia-input'}
                     spellCheck={false}
@@ -409,7 +415,7 @@ export class CommentForm<P extends CommentForm.Props = CommentForm.Props> extend
                 clearInput={this.clearInput}
             />
             <button className={'review-thread-reply-button'} title={'Reply...'} onClick={this.expand}>Reply...</button>
-        </div>;
+        </div> : null;
     }
 }
 

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

@@ -124,12 +124,25 @@ export class CommentThreadImpl implements CommentThread, Disposable {
     private readonly onDidChangeCollapsibleStateEmitter = new Emitter<CommentThreadCollapsibleState | undefined>();
     readonly onDidChangeCollapsibleState = this.onDidChangeCollapsibleStateEmitter.event;
 
+    private readonly onDidChangeCanReplyEmitter = new Emitter<boolean>();
+    readonly onDidChangeCanReply = this.onDidChangeCanReplyEmitter.event;
+
     private _isDisposed: boolean;
 
     get isDisposed(): boolean {
         return this._isDisposed;
     }
 
+    private _canReply: boolean = true;
+    get canReply(): boolean {
+        return this._canReply;
+    }
+
+    set canReply(canReply: boolean) {
+        this._canReply = canReply;
+        this.onDidChangeCanReplyEmitter.fire(this._canReply);
+    }
+
     constructor(
         public commentThreadHandle: number,
         public controllerHandle: number,
@@ -150,6 +163,7 @@ export class CommentThreadImpl implements CommentThread, Disposable {
         if (modified('contextValue')) { this._contextValue = changes.contextValue; }
         if (modified('comments')) { this._comments = changes.comments; }
         if (modified('collapseState')) { this._collapsibleState = changes.collapseState; }
+        if (modified('canReply')) { this._canReply = changes.canReply!; }
     }
 
     dispose(): void {
@@ -159,6 +173,7 @@ export class CommentThreadImpl implements CommentThread, Disposable {
         this.onDidChangeInputEmitter.dispose();
         this.onDidChangeLabelEmitter.dispose();
         this.onDidChangeRangeEmitter.dispose();
+        this.onDidChangeCanReplyEmitter.dispose();
     }
 }
 

package/src/main/browser/debug/plugin-debug-adapter-contribution.ts

@@ -37,27 +37,6 @@ export class PluginDebugAdapterContribution {
         return this.description.label;
     }
 
-    /**
-     * @deprecated since 1.24.0, Use [PluginDebugConfigurationProvider](plugin-debug-configuration-provider.ts)
-     */
-    async provideDebugConfigurations(workspaceFolderUri: string | undefined, dynamic: boolean = false): Promise<DebugConfiguration[]> {
-        return this.debugExt.$provideDebugConfigurations(this.type, workspaceFolderUri, dynamic);
-    }
-
-    /**
-     * @deprecated since 1.24.0, Use [PluginDebugConfigurationProvider](plugin-debug-configuration-provider.ts)
-     */
-    async resolveDebugConfiguration(config: DebugConfiguration, workspaceFolderUri: string | undefined): Promise<DebugConfiguration | undefined> {
-        return this.debugExt.$resolveDebugConfigurations(config, workspaceFolderUri);
-    }
-
-    /**
-     * @deprecated since 1.24.0, Use [PluginDebugConfigurationProvider](plugin-debug-configuration-provider.ts)
-     */
-    async resolveDebugConfigurationWithSubstitutedVariables(config: DebugConfiguration, workspaceFolderUri: string | undefined): Promise<DebugConfiguration | undefined> {
-        return this.debugExt.$resolveDebugConfigurationWithSubstitutedVariables(config, workspaceFolderUri);
-    }
-
     async createDebugSession(config: DebugConfiguration): Promise<string> {
         await this.pluginService.activateByDebug('onDebugAdapterProtocolTracker', config.type);
         return this.debugExt.$createDebugSession(config);

package/src/main/browser/debug/plugin-debug-configuration-provider.ts

@@ -27,8 +27,14 @@ export class PluginDebugConfigurationProvider implements DebugConfigurationProvi
     public type: string;
     public triggerKind: DebugConfigurationProviderTriggerKind;
     provideDebugConfigurations: (folder: string | undefined) => Promise<DebugConfiguration[]>;
-    resolveDebugConfiguration: (folder: string | undefined, debugConfiguration: DebugConfiguration) => Promise<DebugConfiguration | undefined>;
-    resolveDebugConfigurationWithSubstitutedVariables: (folder: string | undefined, debugConfiguration: DebugConfiguration) => Promise<DebugConfiguration | undefined>;
+    resolveDebugConfiguration: (
+        folder: string | undefined,
+        debugConfiguration: DebugConfiguration
+    ) => Promise<DebugConfiguration | undefined | null>;
+    resolveDebugConfigurationWithSubstitutedVariables: (
+        folder: string | undefined,
+        debugConfiguration: DebugConfiguration
+    ) => Promise<DebugConfiguration | undefined | null>;
 
     constructor(
         description: DebugConfigurationProviderDescriptor,

package/src/main/browser/debug/plugin-debug-service.ts

@@ -147,52 +147,74 @@ export class PluginDebugService implements DebugService {
         return configurationsRecord;
     }
 
-    async resolveDebugConfiguration(config: DebugConfiguration, workspaceFolderUri: string | undefined): Promise<DebugConfiguration> {
-        let resolved = config;
-
+    async resolveDebugConfiguration(
+        config: DebugConfiguration,
+        workspaceFolderUri: string | undefined
+    ): Promise<DebugConfiguration | undefined | null> {
         const allProviders = Array.from(this.configurationProviders.values());
+
+        const resolvers = allProviders
+            .filter(p => p.type === config.type && !!p.resolveDebugConfiguration)
+            .map(p => p.resolveDebugConfiguration);
+
         // Append debug type '*' at the end
-        const pluginProviders = allProviders.filter(p => p.type === config.type && !!p.resolveDebugConfiguration);
-        pluginProviders.push(...allProviders.filter(p => p.type === '*' && !!p.resolveDebugConfiguration));
+        resolvers.push(
+            ...allProviders
+                .filter(p => p.type === '*' && !!p.resolveDebugConfiguration)
+                .map(p => p.resolveDebugConfiguration)
+        );
 
-        for (const provider of pluginProviders) {
-            try {
-                const next = await provider.resolveDebugConfiguration(workspaceFolderUri, resolved);
-                if (next) {
-                    resolved = next;
-                } else {
-                    return resolved;
-                }
-            } catch (e) {
-                console.error(e);
-            }
-        }
+        const resolved = await this.resolveDebugConfigurationByResolversChain(config, workspaceFolderUri, resolvers);
 
-        return this.delegated.resolveDebugConfiguration(resolved, workspaceFolderUri);
+        return resolved ? this.delegated.resolveDebugConfiguration(resolved, workspaceFolderUri) : resolved;
     }
 
-    async resolveDebugConfigurationWithSubstitutedVariables(config: DebugConfiguration, workspaceFolderUri: string | undefined): Promise<DebugConfiguration> {
-        let resolved = config;
-
+    async resolveDebugConfigurationWithSubstitutedVariables(
+        config: DebugConfiguration,
+        workspaceFolderUri: string | undefined
+    ): Promise<DebugConfiguration | undefined | null> {
         const allProviders = Array.from(this.configurationProviders.values());
+
+        const resolvers = allProviders
+            .filter(p => p.type === config.type && !!p.resolveDebugConfigurationWithSubstitutedVariables)
+            .map(p => p.resolveDebugConfigurationWithSubstitutedVariables);
+
         // Append debug type '*' at the end
-        const pluginProviders = allProviders.filter(p => p.type === config.type && !!p.resolveDebugConfigurationWithSubstitutedVariables);
-        pluginProviders.push(...allProviders.filter(p => p.type === '*' && !!p.resolveDebugConfigurationWithSubstitutedVariables));
+        resolvers.push(
+            ...allProviders
+                .filter(p => p.type === '*' && !!p.resolveDebugConfigurationWithSubstitutedVariables)
+                .map(p => p.resolveDebugConfigurationWithSubstitutedVariables)
+        );
 
-        for (const provider of pluginProviders) {
+        const resolved = await this.resolveDebugConfigurationByResolversChain(config, workspaceFolderUri, resolvers);
+
+        return resolved
+            ? this.delegated.resolveDebugConfigurationWithSubstitutedVariables(resolved, workspaceFolderUri)
+            : resolved;
+    }
+
+    protected async resolveDebugConfigurationByResolversChain(
+        config: DebugConfiguration,
+        workspaceFolderUri: string | undefined,
+        resolvers: ((
+            folder: string | undefined,
+            debugConfiguration: DebugConfiguration
+        ) => Promise<DebugConfiguration | null | undefined>)[]
+    ): Promise<DebugConfiguration | undefined | null> {
+        let resolved: DebugConfiguration | undefined | null = config;
+        for (const resolver of resolvers) {
             try {
-                const next = await provider.resolveDebugConfigurationWithSubstitutedVariables(workspaceFolderUri, resolved);
-                if (next) {
-                    resolved = next;
-                } else {
-                    return resolved;
+                if (!resolved) {
+                    // A provider has indicated to stop and process undefined or null as per specified in the vscode API
+                    // https://code.visualstudio.com/api/references/vscode-api#DebugConfigurationProvider
+                    break;
                 }
+                resolved = await resolver(workspaceFolderUri, resolved);
             } catch (e) {
                 console.error(e);
             }
         }
-
-        return this.delegated.resolveDebugConfigurationWithSubstitutedVariables(resolved, workspaceFolderUri);
+        return resolved;
     }
 
     registerDebugger(contribution: DebuggerContribution): Disposable {

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

@@ -50,7 +50,7 @@ import * as theia from '@theia/plugin';
 import { UriComponents } from '../../common/uri-components';
 import { CancellationToken } from '@theia/core/lib/common';
 import { LanguageSelector, RelativePattern } from '@theia/callhierarchy/lib/common/language-selector';
-import { CallHierarchyService, CallHierarchyServiceProvider, Definition } from '@theia/callhierarchy/lib/browser';
+import { CallHierarchyService, CallHierarchyServiceProvider, CallHierarchyItem } from '@theia/callhierarchy/lib/browser';
 import { toDefinition, toUriComponents, fromDefinition, fromPosition, toCaller, toCallee } from './callhierarchy/callhierarchy-type-converters';
 import { Position, DocumentUri, DiagnosticTag } from '@theia/core/shared/vscode-languageserver-protocol';
 import { ObjectIdentifier } from '../../common/object-identifier';
@@ -804,8 +804,12 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             selector: language,
             getRootDefinition: (uri: DocumentUri, position: Position, cancellationToken: CancellationToken) =>
                 this.proxy.$provideRootDefinition(handle, toUriComponents(uri), fromPosition(position), cancellationToken)
-                    .then(def => Array.isArray(def) ? def.map(item => toDefinition(item)) : toDefinition(def)),
-            getCallers: (definition: Definition, cancellationToken: CancellationToken) => this.proxy.$provideCallers(handle, fromDefinition(definition), cancellationToken)
+                    .then(def => {
+                        if (!def) { return undefined; }
+                        const defs = Array.isArray(def) ? def : [def];
+                        return { dispose: () => this.proxy.$releaseCallHierarchy(handle, defs[0]?._sessionId), items: defs.map(item => toDefinition(item)) };
+                    }),
+            getCallers: (definition: CallHierarchyItem, cancellationToken: CancellationToken) => this.proxy.$provideCallers(handle, fromDefinition(definition), cancellationToken)
                 .then(result => {
                     if (!result) {
                         return undefined!;
@@ -818,7 +822,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
                     return undefined!;
                 }),
 
-            getCallees: (definition: Definition, cancellationToken: CancellationToken) => this.proxy.$provideCallees(handle, fromDefinition(definition), cancellationToken)
+            getCallees: (definition: CallHierarchyItem, cancellationToken: CancellationToken) => this.proxy.$provideCallees(handle, fromDefinition(definition), cancellationToken)
                 .then(result => {
                     if (!result) {
                         return undefined;

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

@@ -57,6 +57,7 @@ import { CustomEditorsMainImpl } from './custom-editors/custom-editors-main';
 import { SecretsMainImpl } from './secrets-main';
 import { WebviewViewsMainImpl } from './webview-views/webview-views-main';
 import { MonacoLanguages } from '@theia/monaco/lib/browser/monaco-languages';
+import { NotificationExtImpl } from '../../plugin/notification';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const authenticationMain = new AuthenticationMainImpl(rpc, container);
@@ -108,6 +109,9 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const notificationMain = new NotificationMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.NOTIFICATION_MAIN, notificationMain);
 
+    const notificationExt = new NotificationExtImpl(rpc);
+    rpc.set(MAIN_RPC_CONTEXT.NOTIFICATION_EXT, notificationExt);
+
     const terminalMain = new TerminalServiceMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.TERMINAL_MAIN, terminalMain);
 

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,10 +39,12 @@ 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,
@@ -52,12 +54,15 @@ export class StatusBarMessageRegistryMainImpl implements StatusBarMessageRegistr
         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,