Get tree tooltip when needed

Part of #100741

src/vs/vscode.proposed.d.ts

@@ -1150,6 +1150,8 @@ declare module 'vscode' {
 
 	}
 
+	export type TreeTooltipProvider = () => Thenable<MarkdownString>;
+
 	export class TreeItem2 extends TreeItem {
 		/**
 		 * Label describing this item. When `falsy`, it is derived from [resourceUri](#TreeItem.resourceUri).
@@ -1159,7 +1161,7 @@ declare module 'vscode' {
 		/**
 		 * Content to be shown when you hover over the tree item.
 		 */
-		tooltip?: string | MarkdownString | /* for compilation */ any;
+		tooltip?: string | TreeTooltipProvider | /* for compilation */ any;
 
 		/**
 		 * Accessibility information used when screen reader interacts with this tree item.

src/vs/workbench/api/browser/mainThreadTreeViews.ts

@@ -5,7 +5,7 @@
 
 import { Disposable } from 'vs/base/common/lifecycle';
 import { ExtHostContext, MainThreadTreeViewsShape, ExtHostTreeViewsShape, MainContext, IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
-import { ITreeViewDataProvider, ITreeItem, IViewsService, ITreeView, IViewsRegistry, ITreeViewDescriptor, IRevealOptions, Extensions } from 'vs/workbench/common/views';
+import { ITreeViewDataProvider, ITreeItem, IViewsService, ITreeView, IViewsRegistry, ITreeViewDescriptor, IRevealOptions, Extensions, TREE_TOOLTIP_PROVIDER } from 'vs/workbench/common/views';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { distinct } from 'vs/base/common/arrays';
 import { INotificationService } from 'vs/platform/notification/common/notification';
@@ -219,6 +219,11 @@ class TreeViewDataProvider implements ITreeViewDataProvider {
 		if (elements) {
 			for (const element of elements) {
 				this.itemsMap.set(element.handle, element);
+				if (element.tooltip === TREE_TOOLTIP_PROVIDER) {
+					element.tooltip = () => {
+						return this._proxy.$getTooltip(this.treeViewId, element.handle);
+					};
+				}
 				result.push(element);
 			}
 		}

src/vs/workbench/api/common/extHost.protocol.ts

@@ -987,6 +987,7 @@ export interface ExtHostTreeViewsShape {
 	$setExpanded(treeViewId: string, treeItemHandle: string, expanded: boolean): void;
 	$setSelection(treeViewId: string, treeItemHandles: string[]): void;
 	$setVisible(treeViewId: string, visible: boolean): void;
+	$getTooltip(treeViewId: string, treeItemHandle: string): Promise<IMarkdownString | undefined>;
 }
 
 export interface ExtHostWorkspaceShape {

src/vs/workbench/api/common/extHostTreeViews.ts

@@ -10,7 +10,7 @@ import { URI } from 'vs/base/common/uri';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
 import { ExtHostTreeViewsShape, MainThreadTreeViewsShape } from './extHost.protocol';
-import { ITreeItem, TreeViewItemHandleArg, ITreeItemLabel, IRevealOptions } from 'vs/workbench/common/views';
+import { ITreeItem, TreeViewItemHandleArg, ITreeItemLabel, IRevealOptions, TreeTooltipProvider as TreeTooltipProvider, TREE_TOOLTIP_PROVIDER } from 'vs/workbench/common/views';
 import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/common/extHostCommands';
 import { asPromise } from 'vs/base/common/async';
 import { TreeItemCollapsibleState, ThemeIcon } from 'vs/workbench/api/common/extHostTypes';
@@ -19,8 +19,8 @@ import { equals, coalesce } from 'vs/base/common/arrays';
 import { ILogService } from 'vs/platform/log/common/log';
 import { checkProposedApiEnabled } from 'vs/workbench/services/extensions/common/extensions';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
-import { MarkdownString } from 'vs/workbench/api/common/extHostTypeConverters';
 import { IMarkdownString } from 'vs/base/common/htmlContent';
+import { MarkdownString } from 'vs/workbench/api/common/extHostTypeConverters';
 
 type TreeItemHandle = string;
 
@@ -143,6 +143,14 @@ export class ExtHostTreeViews implements ExtHostTreeViewsShape {
 		treeView.setVisible(isVisible);
 	}
 
+	$getTooltip(treeViewId: string, treeItemHandle: string): Promise<IMarkdownString | undefined> {
+		const treeView = this.treeViews.get(treeViewId);
+		if (!treeView) {
+			throw new Error(localize('treeView.notRegistered', 'No tree view with id \'{0}\' registered.', treeViewId));
+		}
+		return treeView.getTooltipMarkdown(treeItemHandle);
+	}
+
 	private createExtHostTreeView<T>(id: string, options: vscode.TreeViewOptions<T>, extension: IExtensionDescription): ExtHostTreeView<T> {
 		const treeView = new ExtHostTreeView<T>(id, options, this._proxy, this.commands.converter, this.logService, extension);
 		this.treeViews.set(id, treeView);
@@ -160,6 +168,7 @@ type TreeData<T> = { message: boolean, element: T | Root | false };
 
 interface TreeNode extends IDisposable {
 	item: ITreeItem;
+	tooltipProvider?: TreeTooltipProvider;
 	parent: TreeNode | Root;
 	children?: TreeNode[];
 }
@@ -329,6 +338,17 @@ class ExtHostTreeView<T> extends Disposable {
 		}
 	}
 
+	async getTooltipMarkdown(treeItemHandle: string): Promise<IMarkdownString | undefined> {
+		const element = this.elements.get(treeItemHandle);
+		if (element) {
+			const node = this.nodes.get(element);
+			if (node && node.tooltipProvider) {
+				return node.tooltipProvider();
+			}
+		}
+		return undefined;
+	}
+
 	private resolveUnknownParentChain(element: T): Promise<TreeNode[]> {
 		return this.resolveParent(element)
 			.then((parent) => {
@@ -488,28 +508,33 @@ class ExtHostTreeView<T> extends Disposable {
 		return node;
 	}
 
-	private getTooltip(tooltip?: string | vscode.MarkdownString): string | IMarkdownString | undefined {
-		if (typeof tooltip === 'string') {
-			return tooltip;
-		} else if (tooltip === undefined) {
-			return undefined;
+	private getTooltip(tooltip?: string | vscode.TreeTooltipProvider): { tooltip: string | undefined, provider?: TreeTooltipProvider } {
+		if ((typeof tooltip === 'string') || (tooltip === undefined)) {
+			return { tooltip };
 		} else {
 			checkProposedApiEnabled(this.extension);
-			return MarkdownString.from(tooltip);
+			return {
+				tooltip: TREE_TOOLTIP_PROVIDER,
+				provider: async () => {
+					const resolved = await tooltip();
+					return MarkdownString.from(resolved);
+				}
+			};
 		}
 	}
 
 	private createTreeNode(element: T, extensionTreeItem: vscode.TreeItem2, parent: TreeNode | Root): TreeNode {
 		const disposable = new DisposableStore();
 		const handle = this.createHandle(element, extensionTreeItem, parent);
 		const icon = this.getLightIconPath(extensionTreeItem);
+		const tooltip = this.getTooltip(extensionTreeItem.tooltip);
 		const item = {
 			handle,
 			parentHandle: parent ? parent.item.handle : undefined,
 			label: toTreeItemLabel(extensionTreeItem.label, this.extension),
 			description: extensionTreeItem.description,
 			resourceUri: extensionTreeItem.resourceUri,
-			tooltip: this.getTooltip(extensionTreeItem.tooltip),
+			tooltip: tooltip.tooltip,
 			command: extensionTreeItem.command ? this.commands.toInternal(extensionTreeItem.command, disposable) : undefined,
 			contextValue: extensionTreeItem.contextValue,
 			icon,
@@ -521,6 +546,7 @@ class ExtHostTreeView<T> extends Disposable {
 
 		return {
 			item,
+			tooltipProvider: tooltip.provider,
 			parent,
 			children: undefined,
 			dispose(): void { disposable.dispose(); }

src/vs/workbench/common/views.ts

@@ -617,6 +617,9 @@ export interface ITreeItemLabel {
 
 }
 
+export type TreeTooltipProvider = () => Promise<IMarkdownString | undefined>;
+export const TREE_TOOLTIP_PROVIDER = '__TREE_TOOLTIP_PROVIDER__';
+
 export interface ITreeItem {
 
 	handle: string;
@@ -637,7 +640,7 @@ export interface ITreeItem {
 
 	resourceUri?: UriComponents;
 
-	tooltip?: string | IMarkdownString;
+	tooltip?: string | TreeTooltipProvider;
 
 	contextValue?: string;
 

src/vs/workbench/contrib/views/browser/treeView.ts

@@ -13,7 +13,7 @@ import { IContextMenuService } from 'vs/platform/contextview/browser/contextView
 import { IMenuService, MenuId, MenuItemAction, registerAction2, Action2 } from 'vs/platform/actions/common/actions';
 import { ContextAwareMenuEntryActionViewItem, createAndFillInContextMenuActions } from 'vs/platform/actions/browser/menuEntryActionViewItem';
 import { IContextKeyService, ContextKeyExpr, ContextKeyEqualsExpr, RawContextKey, IContextKey } from 'vs/platform/contextkey/common/contextkey';
-import { ITreeView, ITreeItem, TreeItemCollapsibleState, ITreeViewDataProvider, TreeViewItemHandleArg, ITreeItemLabel, IViewDescriptorService, ViewContainer, ViewContainerLocation } from 'vs/workbench/common/views';
+import { ITreeView, ITreeItem, TreeItemCollapsibleState, ITreeViewDataProvider, TreeViewItemHandleArg, ITreeItemLabel, IViewDescriptorService, ViewContainer, ViewContainerLocation, TreeTooltipProvider } from 'vs/workbench/common/views';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { IProgressService } from 'vs/platform/progress/common/progress';
@@ -788,11 +788,10 @@ class TreeRenderer extends Disposable implements ITreeRenderer<ITreeItem, FuzzyS
 		this.setupHovers(node.tooltip, templateData.container, disposableStore);
 	}
 
-	private setupHovers(tooltip: string | IMarkdownString | undefined, htmlElement: HTMLElement, disposableStore: DisposableStore): void {
+	private setupHovers(tooltip: string | TreeTooltipProvider | undefined, htmlElement: HTMLElement, disposableStore: DisposableStore): void {
 		if (!tooltip || isString(tooltip)) {
 			return;
 		}
-		const text: IMarkdownString = tooltip;
 		const hoverService = this.hoverService;
 		const hoverDelay = this.hoverDelay;
 		function mouseOver(this: HTMLElement, e: MouseEvent): any {
@@ -801,9 +800,10 @@ class TreeRenderer extends Disposable implements ITreeRenderer<ITreeItem, FuzzyS
 				isHovering = false;
 			}
 			this.addEventListener(DOM.EventType.MOUSE_LEAVE, mouseLeave, { passive: true });
-			setTimeout(() => {
-				if (isHovering) {
-					hoverService.showHover({ text, target: this });
+			setTimeout(async () => {
+				let resolvedTooltip: IMarkdownString | undefined;
+				if (isHovering && tooltip && !isString(tooltip) && (resolvedTooltip = await tooltip())) {
+					hoverService.showHover({ text: resolvedTooltip, target: this });
 				}
 				this.removeEventListener(DOM.EventType.MOUSE_LEAVE, mouseLeave);
 			}, hoverDelay);