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

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

@@ -355,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));
             }
@@ -185,6 +185,7 @@ type CommentThreadModification = Partial<{
     contextValue: string | undefined,
     comments: theia.Comment[],
     collapsibleState: theia.CommentThreadCollapsibleState
+    canReply: boolean;
 }>;
 
 export class ExtHostCommentThread implements theia.CommentThread, theia.Disposable {
@@ -283,6 +284,17 @@ export class ExtHostCommentThread implements theia.CommentThread, theia.Disposab
         return this._isDisposed;
     }
 
+    private _canReply: boolean = true;
+    get canReply(): boolean {
+        return this._canReply;
+    }
+
+    set canReply(canReply: boolean) {
+        this._canReply = canReply;
+        this.modifications.canReply = canReply;
+        this._onDidUpdateCommentThread.fire();
+    }
+
     private commentsMap: Map<theia.Comment, number> = new Map<theia.Comment, number>();
 
     private acceptInputDisposables = new DisposableCollection();
@@ -345,6 +357,9 @@ export class ExtHostCommentThread implements theia.CommentThread, theia.Disposab
         if (modified('collapsibleState')) {
             formattedModifications.collapseState = convertToCollapsibleState(this.collapseState);
         }
+        if (modified('canReply')) {
+            formattedModifications.canReply = this.canReply;
+        }
         this.modifications = {};
 
         this.proxy.$updateCommentThread(

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;

package/src/plugin/quick-open.ts

@@ -451,6 +451,7 @@ export class QuickInputExt implements QuickInput {
     }
 
     _fireChangedValue(changedValue: string): void {
+        this._value = changedValue;
         this._onDidChangeValueEmitter.fire(changedValue);
     }
 
@@ -533,39 +534,6 @@ export class InputBoxExt extends QuickInputExt implements InputBox {
             this.update({ validationMessage });
         }
     }
-
-    override async show(): Promise<void> {
-        super.show();
-
-        const update = (value: string) => {
-            this.value = value;
-            if (this.validationMessage && this.validationMessage.length > 0) {
-                return this.validationMessage;
-            }
-        };
-
-        this.quickOpen.showInputBox({
-            id: this._id,
-            busy: this.busy,
-            buttons: this.buttons,
-            enabled: this.enabled,
-            ignoreFocusOut: this.ignoreFocusOut,
-            password: this.password,
-            placeholder: this.placeholder,
-            prompt: this.prompt,
-            step: this.step,
-            title: this.title,
-            totalSteps: this.totalSteps,
-            validationMessage: this.validationMessage,
-            value: this.value,
-            visible: this.visible,
-            validateInput(value: string): string | undefined {
-                if (value.length > 0) {
-                    return update(value);
-                }
-            }
-        });
-    }
 }
 
 /**

package/src/plugin/status-bar/status-bar-item.ts

@@ -20,14 +20,22 @@ import { UUID } from '@theia/core/shared/@phosphor/coreutils';
 
 export class StatusBarItemImpl implements theia.StatusBarItem {
 
+    /** Map from allowed background colors to corresponding foreground colors. */
+    private static BACKGROUND_COLORS = new Map<string, string>([
+        ['statusBarItem.errorBackground', 'statusBarItem.errorForeground'],
+        ['statusBarItem.warningBackground', 'statusBarItem.warningForeground']
+    ]);
+
     private _id: string;
 
     private _alignment: StatusBarAlignment;
     private _priority: number;
 
+    private _name: string | undefined;
     private _text: string;
     private _tooltip: string;
-    private _color: string | ThemeColor;
+    private _color: string | ThemeColor | undefined;
+    private _backgroundColor: ThemeColor | undefined;
     private _command: string | theia.Command;
     private _accessibilityInformation: theia.AccessibilityInformation;
 
@@ -58,6 +66,10 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
         return this._priority;
     }
 
+    public get name(): string | undefined {
+        return this._name;
+    }
+
     public get text(): string {
         return this._text;
     }
@@ -66,10 +78,14 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
         return this._tooltip;
     }
 
-    public get color(): string | ThemeColor {
+    public get color(): string | ThemeColor | undefined {
         return this._color;
     }
 
+    public get backgroundColor(): ThemeColor | undefined {
+        return this._backgroundColor;
+    }
+
     public get command(): string | theia.Command {
         return this._command;
     }
@@ -78,6 +94,11 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
         return this._accessibilityInformation;
     }
 
+    public set name(name: string | undefined) {
+        this._name = name;
+        this.update();
+    }
+
     public set text(text: string) {
         this._text = text;
         this.update();
@@ -88,11 +109,20 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
         this.update();
     }
 
-    public set color(color: string | ThemeColor) {
+    public set color(color: string | ThemeColor | undefined) {
         this._color = color;
         this.update();
     }
 
+    public set backgroundColor(backgroundColor: ThemeColor | undefined) {
+        if (backgroundColor && StatusBarItemImpl.BACKGROUND_COLORS.has(backgroundColor.id)) {
+            this._backgroundColor = backgroundColor;
+        } else {
+            this._backgroundColor = undefined;
+        }
+        this.update();
+    }
+
     public set command(command: string | theia.Command) {
         this._command = command;
         this.update();
@@ -129,11 +159,22 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
 
             const commandId = typeof this.command === 'object' ? this.command.command : this.command;
             const args = typeof this.command === 'object' ? this.command.arguments : undefined;
+
+            let color = this.color;
+            if (this.backgroundColor) {
+                // If an error or warning background color is set, set the corresponding foreground color
+                color = StatusBarItemImpl.BACKGROUND_COLORS.get(this.backgroundColor.id);
+            }
+
             // Set to status bar
-            this._proxy.$setMessage(this.id, this.text,
+            this._proxy.$setMessage(
+                this.id,
+                this.name,
+                this.text,
                 this.priority,
                 this.alignment,
-                typeof this.color === 'string' ? this.color : this.color && this.color.id,
+                typeof color === 'string' ? color : color?.id,
+                this.backgroundColor?.id,
                 this.tooltip,
                 commandId,
                 this.accessibilityInformation,

package/src/plugin/tree/tree-views.ts

@@ -262,7 +262,8 @@ class TreeViewExtImpl<T> implements Disposable {
             // root
             return [];
         }
-        const parent = this.treeDataProvider.getParent && await this.treeDataProvider.getParent(element);
+        const result = this.treeDataProvider.getParent && await this.treeDataProvider.getParent(element);
+        const parent = result ? result : undefined;
         const chain = await this.calculateRevealParentChain(parent);
         if (!chain) {
             // parents are inconsistent